Fundamentos do Desenvolvimento de Software
Autor: Vguedes | Publicado: 2012-05-02T15:58:00-07:00




Fundamentos do Desenvolvimento de Software

Renato Haddad

Microsoft Most Valuable Professional MVP, MCT, MCPD e MCTS

Tecnologias

Visual Studio .NET 2010, C#



Introdução

Neste artigo irei abordar alguns tópicos básicos que todo desenvolvedor deve saber. A pedidos, os tópicos serão básicos porque este artigo faz parte do programa Microsoft Academy Awards, Módulo Estruturas de decisão e repetição e Programação Orientada a Objeto – OOP.



Decidi usar a linguagem Visual C# simplesmente porque a maioria dos exemplos encontrados na web usam C#. Neste artigo abordarei as estruturas de decisões e repetições, programação orientada a objetos, como criar uma classe, adicionar propriedades, métodos e um construtor. Para finalizar, como herdar uma classe e as vantagens.



Estruturas de decisões

Toda aplicação que precise de um direcionamento do fluxo de execução dos códigos, utiliza os comandos de condições, os quais têm como objetivo avaliar uma condição e conforme o resultado, direcionar o fluxo para uma operação, seja ela um bloco de códigos, uma função, etc.



O primeiro e o mais conhecido é o&nbsp;if&nbsp;(se). Sua sintaxe é:



If ( condição ) ... else / else if ( condição )



Basicamente a condição pode ser uma expressão lógica ou relacional. No exemplo a seguir é definida a variável idade com valor 12 e o if avalia se a idade é maior ou igual a 18. Caso seja verdadeiro, então será mostrada a mensagem "Maior de idade". Neste caso, há apenas uma instrução a ser executada.



var idade = 12;

if (idade &gt;= 18) Console.WriteLine("Maior de idade");



Já no próximo exemplo note que dependendo da condição há um bloco de código a ser executado, sendo que o mesmo deverá estar entre chave {}. Neste caso, se a idade for maior ou igual a 18, então, será mostrada a mensagem "responsável", a idade será somada mais 2 anos, ou seja o resultado final é 14, e ao final, será mostrado o valor da variável já com o novo valor.

Note que neste código tem o uso do&nbsp;else, o qual é a ação falsa da expressão avaliada. Ou seja, neste caso se a idade não for maior ou igual a 18, serão mostradas duas mensagens ("Requer auxilio dos pais") e a idade (neste caso, 10), pois o -= subtrai 2 do valor atual de 12.

Enfim, em situações onde requer a execução de códigos ou blocos de códigos conforme a expressão avaliada, use o else.



if (idade &gt;= 18)

{

&nbsp;&nbsp;&nbsp; Console.WriteLine("responsável");

&nbsp;&nbsp;&nbsp; idade += 2;

&nbsp;&nbsp;&nbsp; Console.WriteLine(idade);

}

else

{

&nbsp;&nbsp;&nbsp; Console.WriteLine("Requer auxilio dos pais");

&nbsp;&nbsp;&nbsp; idade -= 2;

&nbsp;&nbsp;&nbsp; Console.WriteLine(idade);

}



Aprimorando um pouco o uso do&nbsp;if, veja no exemplo a seguir que há três situações possíveis de resultado. A idade inicial é 13, e a primeira expressão avalia se a idade é igual (==) a 10. Caso verdadeiro, mostra a mensagem "igual a 10". Caso contrário, é avaliada a segunda expressão, pois o uso do&nbsp;else if&nbsp;(senão se) avalia se a idade é maior ou igual a 12 E (&amp;&amp;) menor ou igual a 16. Veja que neste caso é a mesma coisa que dizer entre 12 e 16, inclusive. Observe o uso do &amp;&amp; o qual significa o E de forma que ambas as expressões devem ser verdadeiras. Caso seja, será mostrada a mensagem "Adolescente". Neste exemplo se nenhuma das duas expressões anteriores for verdadeira, então o fluxo cairá no&nbsp;else&nbsp;e mostrará "maior que 16". Detalhe: quantos&nbsp;else if&nbsp;posso ter? Quantos forem necessários, não há limites.



idade = 13;

if (idade == 10)

&nbsp;&nbsp;&nbsp; Console.WriteLine("igual a 10");

else if (idade &gt;= 12 &amp;&amp; idade &lt;=16)

&nbsp;&nbsp;&nbsp; Console.WriteLine("Adolescente");

else

&nbsp;&nbsp;&nbsp; Console.WriteLine("maior que 16");







Assim com temos o E (&amp;&amp;), o uso do OU (||) é muito comum. Neste exemplo a seguir a mensagem "condição OU satisfeita" será exibida somente se a idade for igual a 1 OU igual a 10. Caso contrário, jamais este código será executado.



if (idade == 1 || idade == 10)

&nbsp;&nbsp;&nbsp; Console.WriteLine("condicao OU satisfeita");





Já pensou em escrever um código com muitos&nbsp;IFs? Não faz muito sentido isto. Em minha opinião fica um código que chamamos de sujo, de difícil manutenção, então se faz uso do comando&nbsp;swtich. Veja o exemplo a seguir: a variável linguagem contém o texto "cs". O&nbsp;swtich&nbsp;avalia exatamente esta expressão&nbsp;swtich&nbsp;(linguagem). Dentro do bloco você deve colocar o&nbsp;case&nbsp;para cada condição a ser avaliada, e de acordo com o resultado, executa-se o código. Neste caso, dependendo das condições (vb&nbsp;ou&nbsp;cs) será mostrada a respectiva mensagem. Note que se nenhuma acima for atendida, então o fluxo cai no default. Observe que há a palavra chave&nbsp;break, que tem a finalidade de encerrar o&nbsp;swtich&nbsp;e seguir a execução dos códigos abaixo do fechamento do bloco doswtich. O&nbsp;break&nbsp;não é obrigatório mas se você não colocar, a cada&nbsp;case&nbsp;será realizado o questionamento da expressão.





string linguagem = "cs";

switch (linguagem)

{

&nbsp;&nbsp;&nbsp; case "vb":

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Console.WriteLine("vb.net");

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; break;

&nbsp;&nbsp;&nbsp; case "cs":

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Console.WriteLine("c sharp");

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; break;

&nbsp;&nbsp;&nbsp; default:

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Console.WriteLine("outra linguagem");

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; break;

}





Agora vamos ao uso de loopings. Como o próprio nome diz, looping é um laço o qual pode ser finito ou infinito, depende como programar. O&nbsp;while&nbsp;é um tipo de looping bastante usado o qual tem como finalidade realizar a execução do bloco de código de acordo com a expressão definida no escopo do&nbsp;while. Veja que defini duas variáveis, uma boleana (lógica) chamada&nbsp;cond&nbsp;com o valor&nbsp;true; e a contador do tipo int com valor 50. Veja a sintaxe do&nbsp;while&nbsp;(cond), ou seja, enquanto verdadeiro. Neste caso, enquanto a variável&nbsp;cond&nbsp;for verdadeira o looping será executado. Por segurança, dentro do bloco do looping, a cada iteração eu fiz uma condição&nbsp;if&nbsp;que avalia se o contador é igual a 60. Caso seja verdadeiro, a variável&nbsp;cond&nbsp;passa a ser&nbsp;false&nbsp;e não próxima execução da iteração, o looping será finalizado. Vale dizer que a cada iteração é mostrado o valor do contador, e também é adicionado um (contador++) à variável.



bool cond = true;

int contador = 50;

while (cond)

{

&nbsp;&nbsp;&nbsp; if (contador == 60) cond = false;

&nbsp;&nbsp;&nbsp; Console.WriteLine(contador++);

}





Outro tipo de looping muito usado é o&nbsp;foreach&nbsp;(para cada item), o qual você não precisa dizer quantas iterações terão. Neste exemplo, defini um array de string[] chamado&nbsp;áreascontendo quatro siglas de departamentos. Já no&nbsp;foreach&nbsp;veja que a sintaxe é simples e intuitiva, ou seja, para cada item contido em&nbsp;áreas&nbsp;(coleção de itens) execute o bloco de código.

O&nbsp;foreach&nbsp;é extensamente utilizado em coleções de dados, leitura de dados em banco de dados, enfim, você não precisa controlar o final pois está encapsulado no&nbsp;foreach, é ele que controla o término.



string[] areas = { "DTI", "DPE", "WIN", "COR" };

foreach (var item in areas)

{

&nbsp;&nbsp;&nbsp; Console.WriteLine(item);

}





Outro tipo de looping muito difundido em todas as linguagens é o&nbsp;for. A sintaxe é simples, mas vamos entendê-la. O&nbsp;int i = 0&nbsp;inicializa a variável&nbsp;i&nbsp;do tipo&nbsp;int&nbsp;com valor 0 (zero). A seguir é definido o limite da execução, neste caso a expressão&nbsp;i &lt; 100(enquanto&nbsp;i&nbsp;for menor que 100). Para finalizar, o último parâmetro é o contador a cada iteração, neste caso é somado 1 a variável&nbsp;i.



for (int i = 0; i &lt; 100; i++)

{

&nbsp;&nbsp;&nbsp; Console.WriteLine(i);

}





Tratamento de Erros



Tratar erros é uma das coisas mais importantes nas aplicações. Infelizmente nem todo desenvolvedor faz isto e acaba se perdendo completamente, tornando a aplicação não confiável. A estrutura do tratamento é simples, use o try ... catch ... finally.

Tenha em mente o seguinte: tudo que for código passível de erro coloque no bloco do&nbsp;try. Não importa o que seja, se der erro cairá no&nbsp;catch, e é aqui que você deve tratar o erro. O&nbsp;catch&nbsp;pode ser customizado para tipos definidos de erros, por exemplo, erro de abertura de conexão com banco de dados, divisão por zero, enfim, se você pesquisar pela expressão&nbsp;Exception&nbsp;no help do VS verá quais existem.

No código a seguir, dentro do&nbsp;try&nbsp;forcei um erro de divisão por zero, e como coloquei umcatch&nbsp;para capturar este tipo de erro (DivideByZeroException), é óbvio que será mostrada a mensagem deste&nbsp;catch. Observe que o&nbsp;catch&nbsp;genérico sempre deverá ser usado por último, ou seja, se não cair em nenhum customizado, sobra para o último. A vantagem é que você pode usar uma variável (neste caso&nbsp;ex) para ter acesso às propriedades do erro. Eu usei o&nbsp;ex.Message&nbsp;para mostrar a mensagem de erro do framework.

E o&nbsp;finally, para que serve? Entend o&nbsp;finally&nbsp;da seguinte forma: dando ou não erro, ofinally&nbsp;será executado. Um exemplo simples de uso é nas conexões com banco de dados, dando ou não erro, feche a conexão.



try

{

&nbsp;&nbsp;&nbsp; // bloco de codigos

&nbsp;&nbsp;&nbsp; int valor = 10;

&nbsp;&nbsp;&nbsp; int zero = 0;

&nbsp;&nbsp;&nbsp; Console.WriteLine(valor / zero);

}

catch (DivideByZeroException)

{

&nbsp;&nbsp;&nbsp; Console.WriteLine("Vc nao pode dividir nada por zero");

}

catch (Exception ex)

{

&nbsp;&nbsp;&nbsp; Console.WriteLine(ex.Message);

&nbsp;&nbsp;&nbsp; //throw;

}

finally

{

&nbsp;&nbsp;&nbsp; Console.WriteLine("mostra o finally");

}



Programação Orientada a Objetos



Pensar em .Net é obrigatório saber OOP porque tudo é baseado em OOP.

O que é um objeto?

Um objeto é nada mais que uma classe, que pode ter propriedades e métodos. Propriedades da classe são as características e os métodos são as ações. Neste exemplo a seguir defini a classe chamada Jogador contendo 3 propriedades, sendo&nbsp;id, nome e modalidade. Cada propriedade tem um tipo (int, string, double, datetime, etc). Já os métodos desta classe são Salvar e Excluir, os quais não estão implementados, mas são as ações desta classe.



public class Jogador

{

&nbsp;&nbsp;&nbsp; // propriedades

&nbsp;&nbsp;&nbsp; public int id { get; set; }

&nbsp;&nbsp;&nbsp; public string nome { get; set; }

&nbsp;&nbsp;&nbsp; public string modalidade { get; set; }



&nbsp;&nbsp;&nbsp; // métodos

&nbsp;&nbsp;&nbsp; public void Salvar() { }



&nbsp;&nbsp;&nbsp; public void Excluir() { }

}



Como instanciar um objeto e preenche-lo? No código a seguir veja como instanciar o objeto/classe Jogador e preencher com as propriedades definidas na classe. Eu usei a palavra chave&nbsp;var&nbsp;porque o C# atribui o tipo de acordo o conteúdo e como no&nbsp;new&nbsp;está setado o Jogador, então, automaticamente a variável&nbsp;obj&nbsp;passa a ser do tipo Jogador. Uma vez finalizado o preenchimento você tem acesso a tudo da classe, desde que seja pública é claro. Neste exemplo, será mostrado o nome do Jogador através da propriedade obj.nome.



var obj = new Jogador

{

&nbsp;&nbsp;&nbsp; id = 10,

&nbsp;&nbsp;&nbsp; nome = "Paulo",

&nbsp;&nbsp;&nbsp; modalidade = "xadrez"

};



Console.WriteLine(obj.nome);



Construtor da classe

Quando você precisar instanciar uma classe, mas alguma informação deve ser passada logo no início, você pode inserir o campo no construtor da classe. Exemplificando, veja a mesma classe Jogador contendo a propriedade idade. Observe que logo após a declaração da classe é definido o campo&nbsp;idade&nbsp;e no construtor&nbsp;public Jogador (int idade)&nbsp;já é esperado o valor da idade. Neste caso





public class Jogador

{

&nbsp;&nbsp;&nbsp; public int idade;

&nbsp;&nbsp;&nbsp; public Jogador(int idade)

&nbsp;&nbsp;&nbsp; {

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.idade = idade;

&nbsp;&nbsp;&nbsp; }

&nbsp;&nbsp;&nbsp; // propriedades

&nbsp;&nbsp;&nbsp; public int id { get; set; }

&nbsp;&nbsp;&nbsp; public string nome { get; set; }

&nbsp;&nbsp;&nbsp; public string modalidade { get; set; }



&nbsp;&nbsp;&nbsp; // métodos

&nbsp;&nbsp;&nbsp; public void Salvar() { }



&nbsp;&nbsp;&nbsp; public void Excluir() { }

}



Neste caso, quando instanciar a classe Jogador, a idade deverá ser declarada imediatamente entre parênteses.

var obj = new Jogador(25)

{

&nbsp;&nbsp;&nbsp; id = 10,

&nbsp;&nbsp;&nbsp; nome = "Paulo",

&nbsp;&nbsp;&nbsp; modalidade = "xadrez"

};



Console.WriteLine(obj.nome);





Herança de Classe

Um dos melhores conceitos que existem no OOP é a herança. Isto permite criar uma classe base e herda-la quando necessário. Na classe base normalmente colocamos propriedades e métodos básicos, genéricos e nas classes que herdam esta, colocamos as particularidades.

Veja que criei a classe Xadrez e herdei de Jogador. No C# para herdar uma classe use o:. Neste caso, a classe Xadrez tem as propriedades nível e rating. No entanto, veja que o construtor também usa o idade, pois na classe base Jogador, a idade deve ser declarada quando instânciada.



public class Xadrez : Jogador

{

&nbsp;&nbsp;&nbsp; public Xadrez(int idade):base(10)

&nbsp;&nbsp;&nbsp; {

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.idade = idade;

&nbsp;&nbsp;&nbsp; }

&nbsp;&nbsp;&nbsp; public string nivel { get; set; }

&nbsp;&nbsp;&nbsp; public int rating { get; set; }

}





Agora veja como instanciar a classe Xadrez. Observe que as propriedades&nbsp;id, nome e modalidade&nbsp;não existem em Xadrez. Porém, como Xadrez herda de Jogador, você tem acesso a todas estas propriedades de forma transparente. Isto é fantástico, otimiza código, facilita a manutenção e você consegue estender várias funcionalidades.



var objX = new Xadrez(27)

{

&nbsp;&nbsp;&nbsp; nivel = "avançado",

&nbsp;&nbsp;&nbsp; rating = 10000,

&nbsp;&nbsp;&nbsp; id = 20,

&nbsp;&nbsp;&nbsp; nome = "Alvaro",

&nbsp;&nbsp;&nbsp; modalidade = "xadrez"

};

Console.WriteLine(objX.rating);



Vale dizer que todas as propriedades e métodos vistos aqui são públicos (public). Caso queira que uma propriedade seja vista apenas de dentro da classe, use&nbsp;private&nbsp;ouprotected. Isto vale para métodos também.



Sobre o Autor

Renato Haddad (rehaddad@msn.com&nbsp; –&nbsp;www.renatohaddad.com&nbsp;) é MVP, MCT, MCPD e MCTS, palestrante em eventos da Microsoft em diversos países, ministra treinamentos focados em produtividade com o VS.NET 2010, ASP.NET 4, Entity Framework, Reporting Services e Windows Phone. Visite o blog&nbsp;http://weblogs.asp.net/renatohaddad.