Tags: , , , | Categories: Metodologia Posted by Rafael on 30/10/2010 05:43 | Comentários (2)

Pessoal, hoje venho com um post bem pequeno, porém interessante. Na verdade, é mais uma curiosidade sobre Terminologias de TI.

Já ouvi diversas vezes: "Utilizamos uma Medologia de Desenvolvimento baseado em RUP na empresa na qual eu trabalho", ou então, "Utilizamos um Processo de Desenvolvimento baseado em RUP na empresa na qual eu trabalho".

Mas, afinal de contas, Metodologia e Processo são a mesma coisa?

A resposta é não! 

A Metodologia define o Processo a ser executado. Assim sendo, o que usamos e/ou executamos durante o Desenvolvimento de um Software é um Processo baseado em uma Metodologia qualquer.

Pra quem não sabia a diferença, fica aí a dica.

Até mais!

Tags: , , | Categories: Padrões de Projeto Posted by Rafael on 19/10/2010 06:12 | Comentários (4)

Com esse post, inicio uma série sobre Padrões de Projeto (Design Patterns). Abordarei os 23 padrões de projeto de uma forma bem simples. A minha intenção é fazer uma breve descrição sobre cada padrão, seguindo de alguns exemplos, para ajudar àqueles que desenvolvem aplicativos Orientado a Objetos e não conhecem Padrões de Projeto.

Como citei em um post anterior, Padrões de Projeto devem ser utilizados com ponderação. Cada padrão foi criado para solucionar problemas específicos do dia-a-dia de desenvolvedores, porém, como todo e qualquer padrão, a grande maioria requer maior codificação. Por isso, a sua utilização em demasia, é prejudicial. Podemos chegar ao ponto de querer matar um simples e inofensível inseto com uma bazuca. Totalmente sem sentido.

Portanto, bom senso é muito bem-vindo na utilização de Padrões de Projeto.

Quando usamos padrões, agregamos qualidade ao nosso desenvolvimento. Consequentemente, diminuímos a produtividade. É impossível aumentar a qualidade e a produtividade ao mesmo tempo, de qualquer que seja o produto (no nosso caso, software). O que devemos fazer, é encontrar um ponto ótimo entre qualidade e produtividade, mas isso é assunto pra um outro post, só sobre Qualidade x Produtividade, o que não é o nosso foco agora.

Muitas vezes utilizamos técnicas para resolver problemas e criar soluções no nosso dia-a-dia, e nem sabemos que essas técnicas são padrões de projeto. Isso já aconteceu comigo, principalmente quando comecei a estudar padrões de projeto. Portanto, não se espante se ao longo do nosso estudo, se deparar com um padrão que você já utiliza, mas não sabia que é um padrão de projeto.

Os Padrões de Projeto são classificados em 3 grupos, de acordo com suas finalidades: Padrões de Criação, Padrões Estruturais e Padrões Comportamentais. São eles:

Padrões de Criação:

Padrões Estruturais:

  • Adapter
  • Bridge
  • Composite
  • Decorator
  • Façade
  • Flyweight
  • Proxy

Padrões Comportamentais:

  • Chain of Responsability
  • Command
  • Interpreter
  • Iterator
  • Mediator
  • Memento
  • Observer
  • State
  • Strategy
  • Template Method
  • Visitor

Iniciarei pelos seguintes padrões, que são os mais simples e comuns:

Logo após, darei sequência aos demais padrões.

Espero que gostem.

Aguardem!

Tags: , , , | Categories: Engenharia de Requisitos, Metodologia Posted by Rafael on 17/10/2010 01:46 | Comentários (6)

Já ouvi diversas vezes as pessoas falarem: “Este é o Modelo de Casos de Uso do sistema XYZ”, ou então, “Este é o Diagrama de Casos de Uso do sistema XPTO”. Mas, afinal de contas, Modelos e Diagramas são a mesma coisa? Na verdade, Modelos e Diagramas não são a mesma coisa.

Quando dizemos que determinado documento é um Modelo, estamos dizendo que ele contém a definição de todo o sistema, ou seja, é um único documento que possui todas as informações de um sistema, relativas àquele artefato (Caso de Uso, Seqüência, Atividades, etc.). Por exemplo, um Modelo de Caso de Uso de um sistema, possui todos os casos de uso de um sistema.

Diagramas são perspectivas de um determinado Modelo. Criamos Diagramas para facilitar o entendimento (e conseqüentemente o desenvolvimento) de um sistema, ou seja, criamos perspectivas de um determinado modelo. Assim, quando dizemos que determinado documento é um Diagrama de Casos de Uso, sabemos que se trata de uma perspectiva do Modelo de Casos de Uso.

Por isso, sistemas possuem apenas um Modelo de Caso de Uso, e diversos Diagramas de Caso de Uso. O mesmo é verdadeiro para os demais artefatos.

Tags: , , | Categories: Tecnologia COM Posted by Rafael on 16/10/2010 09:19 | Comentários (0)

Hoje um colega de trabalho me fez a seguinte pergunta: O que é DCOM? De primeira eu não consegui responder com propriedade, mas afirmei que deveria ser alguma variação do COM, tecnologia já ultrapassada, mas ainda presente em várias corporações.

Pesquisei um pouco sobre o que é DCOM, e quero compartilhar isso com vocês, apenas como curiosidade: O que é DCOM e COM e DCOM.

Boa leitura!

Tags: , , , | Categories: ASP.NET, JavaScript Posted by Rafael on 14/10/2010 08:32 | Comentários (4)

Meses atrás eu me deparei com um pequeno problema. Eu precisava fazer com que um botão de uma página ASP.NET fosse desabilitado no clique, e o evento Click do mesmo fosse disparado.

Existem diversas maneiras de implementar essa solução, inclusive com padrões de projeto e melhores práticas. Porém, todo padrão deve ser utilizado com bom senso (falarei mais sobre isso em posts futuros), ou então, poderemos criar uma bazuca para matarmos uma mosca. Não faz o menor sentido.

Sou um grande adepto da utilização de padrões de projeto, porém, busco sempre um meio termo, um "ponto ótimo" ou "ponto de equilíbrio".

Assim sendo, nas circunstâncias que eu me encontrava, implementei da maneira mais rápida e prática possível, resolvendo muito bem o problema, e no tempo que eu precisava.

Até a chamada do evento Click ao clicar, nada demais. Com as facilidades do Microsoft Visual Studio, bastam dois cliques no botão, que o método Click é criado e associado ao botão, juntamente com o evento. Tudo muito rápido e fácil.

Aqui está o código gerado na página ASP.NET, seguido do código gerado no CodeBehind da mesma:

<asp:Button ID="botao" runat="server" Text="Clique" onclick="botao_Click"/>



protected void botao_Click(object sender, EventArgs e)

{

            

}

 

Legal, o evento clique já foi associado a um método pelo atributo onclick.

Existe um atributo chamado OnClientClick que é utilizado para invocar scripts no lado do cliente (client side), ou seja, é utilizado para invocar scripts da própria página. Assim que o evento Click é disparado, o script contido ou referenciado no atributo OnClientClick é invocado, e, se o retorno do script for true, o método associado ao atributo onclick é invocado.

O script em JavaScript e o código do botão da página ASP.NET ficaram assim:

<script type="text/javascript">

    function desabilitarBotao() {

        document.getElementById("botao").disabled = true;

    }

<script>



<asp:Button ID="botao" runat="server" Text="Clique" onclick="botao_Click" 

          OnClientClick="javascript:return desabilitarBotao();"/>

 

Tudo parece estar correto. Porém, quando executamos a página, o botão é desabilitado como desejado, porém, o método botao_Click não é invocado.

Isso ocorre porque o IE desabilita toda e qualquer ação do botão quando o mesmo é desabilitado, o que faz sentido. Se estamos desabilitando um objeto, não queremos que alguma ação relacionada a ele seja disparada.

Agora é que entra a função setTimeout do JavaScript. Vejamos os parâmetros dessa função: setTimeout(code, delay), onde code é o código que queremos adiar sua execução, e delay é o tempo que queremos adiar o código, expresso em milisegundos.

Vamos modificar o script, adicionando a função setTimeout:

<script type="text/javascript">

    function desabilitarBotao() {

        window.setTimeout('document.getElementById("botao").disabled = true;', 50);

        return true;

    }

<script>

 

Definimos um delay de 50 milisegundos.

Para testarmos se o botão é desabilitado e o método do CodeBehind realmente é chamado, inseri um breakpoint dentro do método, e executei a aplicação ASP.NET:

Botão da página desabilitado:

É isso. Espero ter ajudado de alguma forma.

Até a próxima!

Tags: , , | Categories: C#, Linguagem de Programação Posted by Rafael on 12/10/2010 23:19 | Comentários (0)

Quando declaramos variáveis de tipos nativos em C#, sempre um valor default é associado às mesmas. Veja o código abaixo.

As variáveis foram declaradas, e note na coluna Value que cada uma recebeu um valor padrão. Isso, em determinadas situações, pode ser um problema. Imagine que você deseja persistir um objeto em uma tabela do banco de dados, e que, alguns campos dessa tabela permitem a inserção de valores nulos. Na compilação não teremos problemas, porém, uma exception será disparada em tempo de execução, se tentarmos atribuir um valor nulo à alguma propriedade do nosso objeto.

Para resolvermos esse problema, utilizamos os nullable types. Muito simples e fácil, basta inserirmos o símbolo ? à direita do tipo da variável, assim:

Notem na coluna Value que o valor atribuído a cada variável é null, ao invés do valor padrão de cada tipo. Assim, podemos atribuir valores nulos ao nosso objeto, e persisti-lo sem problemas.

Simples assim.

Até a próxima!

Tags: , , | Categories: C#, Linguagem de Programação Posted by Rafael on 12/10/2010 21:37 | Comentários (0)

Dando seqüência à série Operadores C#, vamos falar sobre os operadores de incremento (++) e decremento (--) de variáveis.

Operadores de incremento e decremento de variáveis

O conceito de operadores de incremento e decremento é muito simples. Basicamente, utilizamos o operador de incremento para simplificar a expressão “variável = variável + 1”, ou então o operador de decremento para simplificar a expressão “variável = variável - 1”. O trecho de código abaixo ilustra a sintaxe dos operadores:

    int x = 0;



    // incrementando a variável x

    x = x + 1;



    // incrementando a variável x, utilizando o operador de incremento

    x++;



    // decrementando a variável x

    x = x - 1;



    // decrementando a variável x, utilizando o operador de decremento

    x--;

 

Muito simples e fácil de entender. Agora, consideremos o seguinte trecho de código:

    class Program

    {

        static void Main(string[] args)

        {

            int x = 0;

            int y = 0;

            Console.WriteLine("1º loop:");

            for (int i = 0; i < 5; i++)

            {

                if (x++ == 2)

                {

                    Console.WriteLine("Entrou no if da variável x++");

                }

                if (++y == 2)

                {

                    Console.WriteLine("Entrou no if da variável ++y");

                }

            }

            Console.WriteLine();

            x = 5;

            y = 5;

            Console.WriteLine("2º loop:");

            for (int i = 0; i < 5; i++)

            {

                if (x-- == 2)

                {

                    Console.WriteLine("Entrou no if da variável x--");

                }

                if (--y == 2)

                {

                    Console.WriteLine("Entrou no if da variável --y");

                }

            }

            Console.ReadKey();

        }

    }

 

Vemos que no primeiro loop, as variáveis x e y são incrementadas, porém de maneiras diferentes. A variável x é incrementada após a execução da instrução if (x++ == 2), e a variável y é incrementa antes da execução da instrução if (++y == 2). O mesmo acontece no segundo loop, só que, ao invés das variáveis serem incrementadas, elas são decrementadas. No código acima, utilizamos as mesmas condições dos ifs para demonstrar que as variáveis com operador à esquerda são incrementadas ou decrementadas antes da execução da instrução, e as variáveis com operador à direita são incrementadas ou decrementadas após a execução da instrução. Ao executarmos o código, temos a seguinte saída:

Muito simples e fácil. Espero ter ajudado!

Até a próxima!

Tags: , , | Categories: C#, Linguagem de Programação Posted by Rafael on 10/10/2010 08:02 | Comentários (0)

Apesar de parecer um assunto para iniciantes na linguagem, me surpreendi um dia, junto com um colega de trabalho, descobrindo alguns operadores da linguagem C#, que eu nunca havia utilizado antes. Então, mesmo que você já domine a linguagem C#, de alguma forma, esse post pode ser útil.

Com esse post, inicio uma série de posts sobre operadores C#. Nesse primeiro, vamos falar sobre os operadores lágicos & (and) e | (or) e seus respectivos condicionais && e ||.

Diferença entre os operadores "& e &&" e/ou "| e ||"

Consideremos o seguinte trecho de código:

    class Program

    {

        static void Main(string[] args)

        {

            int x = 0;

            for (int i = 0; i < 10; i++)

            {

                if (false & ++x == 2)

                {

                    // ...

                }

            }

        }

    }

Se inserirmos um breakpoint no código e o debugarmos, veremos que a variável x é incrementada (o incremento de variáveis será abordado no próximo post), mesmo se a condição não for verdadeira:

Porém, se substituirmos o operador & pelo &&, o código ficará assim, e notaremos que a variável x não é alterada.

O mesmo comportamento se repete para os operadores | e ||:

Com o operador |

Agora, substituindo o operador | pelo ||

Com isso, concluímos que quando utilizamos os operadores & e |, todas as partes da condição são verificadas. Notamos isso pois a variável x é incrementada. Porém, quando utilizamos os operadores && e ||, a variável não é incrementada. Isso ocorre porque a verificação é executada da esquerda para a direita, por exemplo, if ( 1ª verificação && 2ª verificação && 3ª verificação ), e, caso a primeira parte (ou segunda parte) da condição seja válida (entenda como condição válida a condição verdadeira para entrada ou não do if), as demais não são verificadas, como observamos nos exemplos acima, ou seja, não é necessária a validação completa da condição.

Bom, é isso.

Espero que tenham gostado.

Até a próxima!

Tags: , | Categories: Pessoal Posted by Rafael on 10/10/2010 07:57 | Comentários (5)

Olá pessoal!

Como primeiro post, eu gostaria de dizer, em poucas palavras, um pouco sobre o que me levou a criar esse blog.

Praticamente todos os dias, nós que trabalhamos com TI, resolvemos problemas, criamos soluções, estudamos novas linguagens de programação, utilizamos métodos, padrões, procedimentos, e, com tudo isso, enriquecemos nosso conhecimento. Porém, muitas vezes, esse conhecimento não é passado a outras pessoas, na maioria das vezes, por falta de oportunidade.

Pensando nisso, resolvi publicar esse blog, abordando diversos assuntos ligados direta ou indiretamente à TI, disseminando um pouco do conhecimento adquiri durante alguns anos de experiência.

Os assuntos dos posts serão variados. Na maioria das vezes, falarei sobre linguagens de programação, em especial C#, mas abordarei outros assuntos como padrões de projetos, engenharia de software, metodologias de desenvolvimento, desenvolvimento web e banco de dados. Alguns assuntos abordarei de maneira mais superficial, outros, detalharei praticamente ao ponto de "escovar bits".

Espero que gostem! Ótima leitura a todos!

Até mais!