Artigos Canal Mais C# - Artigo easy .net Magazine 7

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

Do que trata o artigo

O artigo aprofunda o desenvolvedor em alguns elementos do C# que muitas vezes são deixados de lado. Entre os mais importantes destacam-se o uso de “Dictionary” para criação de listas dinâmicas de dados; a leitura da “string” de conexão com o banco de dados do arquivo de configurações que é criado por padrão nos programas do Microsoft .NET e também alguns aspectos no desenvolvimento de aplicações orientadas a uso do banco de dados. Para desenvolver os tópicos será desenvolvida uma aplicação do tipo “Windows Forms” que formata um relatório em uma tela executando consulta no banco de dados Northwind.

Para que serve

O conhecimento mais profundo dos recursos do framework e boas práticas que devem ser levadas em conta ao se desenvolver as aplicações aceleram o desenvolvimento e também fazem com que a aplicação final criada seja mais estável. É muito comum que a falta de conhecimento sobre determinados recursos da linguagem faça com que o programador perca tempo escrevendo códigos para resolver problemas que já foram anteriormente solucionados.

Em que situação o tema é útil

Quando estiver desenvolvendo programas e precisar criar listas de dados dinâmicas, gravar arquivos de texto, usar configurações dinâmicas etc. Outro ponto importante é a verificação de pontos que deixam a aplicação mais estável e como tratar corretamente erros que podem acontecer.

Resumo do DevMan

Desde a versão 2.0 do framework .NET é possível criar listas dinâmicas de dados. Estas proporcionam simplicidade para trabalhar com dados aumentando ou diminuindo o tamanho da lista. Graças a inclusão de “System.Collections.Generics” os programadores puderam criar qualquer tipo de coleções de dados para qualquer tipo de dado do framework e também suas classes personalizadas. Com o uso de “Dictionary” é possível criar uma lista do tipo “chave-valor” para simplificar o acesso aos elementos da lista através de uma chave mais significativa do que os indexadores numéricos dos vetores. Por ser fortemente tipada, a lista evita problemas oriundos de conversão de dados diminuindo a possibilidade de gerar erros na aplicação e também melhora o desempenho uma vez que dispensa a conversão dos dados.

A criação de aplicações do tipo “Windows forms” está bastante solidificada entre os programadores. Entretanto, existem alguns aspectos a serem considerados que podem facilitar o aprendizado para quem está começando a trabalhar com este tipo de programa. Um aspecto importante é a melhor maneira para se conectar ao banco de dados e recuperar os dados. No artigo, serão dadas algumas opções para tornar este acesso mais dinâmico através do uso dos arquivos de configuração. Normalmente, quando se desenvolve sistemas profissionais, ninguém deseja que a aplicação saia dando mensagens de erro ou mesmo travando durante o funcionamento. Tratar os erros é imperativo para o programador embora, seja preferível evitar que ocorram. Então, durante o desenvolvimento do assunto, darei algumas opções para um tratamento de erros mais cuidadoso.

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.

Nota: Ainda não vamos trabalhar com MVVM e ASP.NET MVC. Este artigo pretende nivelar alguns conhecimentos no desenvolvimento de aplicações Windows usando o C# e alguns dos seus recursos que talvez não sejam muito “populares”. Se você já tem um ótimo conhecimento desta linguagem, o artigo pode ser que esteja aquém do que você está procurando. Se você tem pouco conhecimento, é bom informar-se sobre assuntos como fundamentos da linguagem, criação de classes, orientação a objetos e aplicações “Windows Forms”. Veja, nos itens a seguir alguns requisitos que serão necessários.

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;

Nota: Todos os temas descritos já foram abordados nas edições anteriores da Revista Easy .NET Magazine (veja sessão Saiba Mais).

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.

Nota: em linguagens como o C “puro” isto ainda é feito assim. Os recursos variam muito conforme a plataforma alvo que o programa será escrito.

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:

...

Quer ler esse conteúdo completo? Tenha acesso completo