Atenção: esse artigo tem um vídeo complementar. Clique e assista!

Recentemente o framework.NET recebeu importantes atualizações principalmente no que diz respeito aos recursos disponíveis para o desenvolvimento do que hoje se chamam “aplicações ricas”. Estas nada mais são do que programas com muitos recursos para compor a interface gráfica com o usuário (GUI) além do fato de a interface dos programas Windows ter amadurecido bastante.

Mesmo com a chegada das aplicações “Silverlight” e “Windows Presentation Foundation” (WPF), em alguns casos será necessário criar uma aplicação “Windows forms” até porque este tipo foi mantido na versão 2010 do Visual Studio. Uma das grandes tendências atuais no desenvolvimento de aplicativos comerciais e principalmente dentro da plataforma .NET é separar as regras de manipulação de dados, conexão com o banco e outros aspectos da interface.

Quando começaram a surgir as ferramentas para desenvolvimento “visual” de aplicações rapidamente se difundiu o “click and code”. Este tipo de maneira de programar consiste em se arrastar os controles visuais dentro de um formulário na sua ferramenta de design e, através de um gerenciador de objetos da IDE o programador escrevia pequenos (nem sempre tão pequenos assim) trechos de código que respondiam a eventos como um click em um botão, um texto digitado em um controle, uma opção selecionada em uma caixa de combinação.

Delphi, Visual Studio (usando a linguagem Visual Basic até a versão 6), Visual C++, entre outras IDEs fizeram isto durante anos e muitos (bons) programas foram escritos deste jeito. Mas, os anos passam e o que funcionava muito bem antigamente, já não serve para resolver todos os problemas atualmente. Então, hoje termos como SOLID, ASP.NET MVC e MVVM que oferecem mais do que recursos disponibilizam técnicas para deixar separados acesso a dados, regras de negócio e interface com o usuário.

Para começar, é bom que se tenha bons conhecimentos da linguagem que se está usando e conheça algumas formas de trabalhar procurando desconectar ao máximo código de interface. Escrever classes que resolvam problemas específicos para armazenamento e recuperação de dados é um bom passo. No Visual Studio, você pode separar pastas para armazenar arquivos que fazem determinado trabalho no seu projeto. Geralmente, quando possível, crio uma pasta separada para classes de dados, outra para acesso ao banco, mas, você pode fazer como achar melhor. Criar pastas para classes de regras de negócios, relatórios etc.

Este artigo presume que você esteja relativamente à vontade com os seguintes assuntos:

• Fundamentos da linguagem C# a partir da versão 2.0. Entre estes eu incluo conhecimento dos tipos básicos da linguagem, laços de programação, expressões condicionais;

• Conhecimento de programação orientada a objeto e como usar o C# para criar classes com seus métodos e propriedades;

• Criação de aplicações do tipo “Windows Forms”;

• Conexão com bancos de dados via C# e ADO.NET;

O software que eu usei para desenvolver os exemplos foram os seguintes:

• Microsoft Visual Studio 2010. Porém você pode usar a versão 2008 e até mesmo as versões “Express”;

• SQL Server 2008 Express Edition. Gerenciador de banco de dados gratuito da Microsoft;

• Banco de dados de exemplo Northwind;

• SQL Server Management Studio. Ferramenta usada para conectar-se com bancos de dados do SQL Server 2008.

Listas dinâmicas de dados

Desde as primeiras versões das linguagens de programação, foi necessário trabalhar com listas de dados. Na linguagem C, é muito comum a criação de um vetor de dados de um determinado tipo com uma única linha de código. Algo como:

 int[10] lista = { 0, 1, 2, 3, 5, 7, 11, 13, 17, 19 };

Um problema comum é que o tamanho desta lista precisava ser estabelecido ao se criar o vetor, o que nem sempre atendia às necessidades do programador. Com o tempo, foram surgindo as listas dinâmicas que aumentavam e diminuíam sua dimensão durante a execução do programa, mas, quase sempre, isto era complicado de fazer e, dependendo da linguagem, envolvia trabalhar com ponteiros de memória, coisa não muito fácil.

Na versão 2.0 do .NET em diante tornou-se possível a criação de listas dinâmicas de dados de uma maneira bem fácil. Por exemplo, para criar a lista de números inteiros anteriormente vista, basta seguir a sintaxe:

 List<int> lista = new List<int>( new int[] { 0, 1, 2, 3, 4, 5 } ); 

A vantagem de se usar o código acima que requer “System.Collections.Generics” nas cláusulas “using” é que podemos adicionar um ou vários elementos, um de cada vez ou, de uma vez só:

 // adicionando um elemento por vez
  lista.Add( 6 );
  lista.Add( 7 );
  // adicionando vários elementos
  lista.AddRange( new int[] { 8, 9, 10 } ); 

Se quisermos remover um elemento, basta passar o índice que queremos remover para o método “Remove”:

 // remove o primeiro elemento da lista
  lista.Remove( 0 ); 

Outra característica interessante das listas dinâmicas é que podem ser usadas para qualquer tipo, quer seja nativo do framework ou criado por você. Considere a classe abaixo:

  public class instrumentos
  {
   public string Tipo { get; set; }
   public string Fabricante { get; set; }
   public string Modelo { get; set; }
   public int AnoDeFabricacao { get; set; }
  }

Para criar uma lista dinâmica de objetos usando esta classe basta passar o tipo para o construtor de “List<T>”:

 List<instrumentos> listaInstrumentos = new List<instrumentos>();

E em seguida, adicionar os elementos da lista passando uma nova instância do objeto para o método “Add”:

 listaInstrumentos.Add(
    new instrumentos 
    {
     Tipo = "Guitarra elétrica",
     Fabricante = "Fender",
     Modelo = "Californian Telecaster",
     AnoDeFabricacao = 2000
    });
   
  listaInstrumentos.Add(
    new instrumentos 
    {
     Tipo = "Guitarra elétrica",
     Fabricante = "Fender",
     Modelo = "Californian Stratocaster",
     AnoDeFabricacao = 1998
    });

Mas isto não funciona se você precisar de um vetor de duas dimensões apenas. Além disto, só é possível acessar os elementos da lista se você conhecer qual é o índice base zero onde o elemento está. Por outro lado, se você ainda assim quiser trabalhar com este tipo de lista, precisará criar uma classe (ou “struct”) com pelo menos dois elementos.

Mas, existe outra forma de se fazer isso: “Dictionary<T, U>”. Esta classe que também faz parte de “System.Collections.Genercis”, cria uma lista dinâmica onde o primeiro elemento do vetor é uma chave do tipo “T” (geralmente “string”, mas, pode-se usar qualquer tipo de dado) para valores do tipo “U”.

O tipo de dado a ser usado como chave da lista deve implementar a interface “IComparable” o que garante que uma chave pode ser comparada com outra. Não podem ser adicionadas chaves nulas e nem duplicadas mas, valores podem. Um valor dentro de um “Dictionary” pode ser acessado diretamente pela chave. Veja no exemplo a seguir como criar uma lista com nomes e datas de nascimento para diversas pessoas:

 Dictionary<string, DateTime> lista = new Dictionary<string, DateTime>();

Este código cria a lista na memória usando a classe “Dictionary”. Em seguida, se quiser adicionar os valores, você usa o método “Add” como está descrito a seguir: