Archive for January 2012

Validando Dados com EntityFramework e WindowsForms

Pessoal,

Hoje vou mostrar uma maneira bem simples e interessante de fazer validação de dados com EntityFramework, classes POCO e uma aplicação Windows Forms.

Como eu já comentei em outros posts, quando você utiliza DataAnnotations em classes POCO na sua camada de dados e faz a camada de apresentação com WPF/Silverlight ou MVC, o tratamento dos campos é feito automaticamente, praticamente sem nenhum tipo de código. Mas e se você ainda programa para WindowsForms ou precisa validar os dados da classe em uma camada e retornar o erro para outra camada, como fazer ? Isto é o que veremos a seguir.

Primeiro vamos criar um projeto Windows Forms no Visual Studio 2010:
image

Agora vamos adicionoar o EntityFramework CodeFirst usando o NuGet, como eu expliquei neste post. E logo após vamos criar uma classes chamada Produto e vamos adicionar os annotations nela. Annotations são marcações acima dos campos que definem várias informações ao engine do Entitu Framework, como por exemplo, os valores permitidos no campo.

Nossa classe produto ficará da seguinte maneira:

  1: using System;
  2: using System.Collections.Generic;
  3: using System.Linq;
  4: using System.Text;
  5: using System.ComponentModel.DataAnnotations;
  6: 
  7: namespace WindowsFormsValidacao
  8: {
  9:     [Table("Produto")]
 10:     public class Produto : ValidacaoEntidade 
 11:     {
 12:         public int ID { get; set; }
 13:         [Required(ErrorMessage="Descrição em branco"])
 14:         public string Descricao { get; set; }
 15:         [Range(1,10000,ErrorMessage="Valor deve estar entre 1 e 10000")]
 16:         public double SaldoMinimo { get; set; }
 17:         [Required(ErrorMessage="Custo em branco")]
 18:         public decimal Custo { get; set; }
 19:         public decimal Venda { get; set; }
 20:         [MaxLength(20,ErrorMessage="Tamanho máximo = 20")]
 21:         public string Localizacao { get; set; }
 22:     }
 23: }

Veja que a nossa classe está herdando de ValidacaoEntidade, que é onde iremos fazer o método de validaçao dos campos, veja abaixo:

  1: using System;
  2: using System.Collections.Generic;
  3: using System.Linq;
  4: using System.Text;
  5: using System.ComponentModel;
  6: using System.ComponentModel.DataAnnotations;
  7: using System.Xml.Serialization;
  8: 
  9: namespace WindowsFormsValidacao
 10: {
 11:     public class ValidacaoEntidade : IDataErrorInfo
 12:     {
 13:         [NotMapped]
 14:         public string Error
 15:         {
 16:             get { return ""; }
 17:         }
 18: 
 19:         [NotMapped]
 20:         public string this[string columnName]
 21:         {
 22:             get
 23:             {
 24:                 return ValidateProperty(columnName);
 25:             }
 26:         }
 27: 
 28:         protected string ValidateProperty(string propertyName)
 29:         {
 30:             var info = this.GetType().GetProperty(propertyName);
 31: 
 32:             if (!info.CanWrite)
 33:             {
 34:                 return null;
 35:             }
 36: 
 37:             var value = info.GetValue(this, null);
 38:             IEnumerable<string> errorInfos =
 39:                   (from va in info.GetCustomAttributes(true).OfType<ValidationAttribute>()
 40:                    where !va.IsValid(value)
 41:                    select va.FormatErrorMessage(string.Empty)).ToList();
 42: 
 43: 
 44:             if (errorInfos.Count() > 0)
 45:             {
 46:                 return errorInfos.FirstOrDefault<string>();
 47:             }
 48:             return null;
 49:         }
 50: 
 51:         public IEnumerable<string> Validate(bool Formatar=false)
 52:         {
 53:             foreach (var prop in this.GetType().GetProperties())
 54:             {
 55:                 string err = ValidateProperty(prop.Name);
 56:                 if (!String.IsNullOrWhiteSpace(err))
 57:                 {
 58:                     yield return prop.Name + ": " + err + ((Formatar) ? "<br>" : "").ToString();
 59:                 }
 60:             }
 61:         }
 62:     }
 63: }

Nesta classe está o segredo da validação, o método Validate(). Este método percorre todos os campos da nossa classe e verifica seu CustomAttribute(), procurando pelo ValidationAttribute, que é o nosso DataAnnotations, se o valor não for for válido, ele retorna a mensagem de erro que atribuímos ao campos e vai adicionando a uma lista, que poderemos usar em nossa camada de apresentação.

Adicionamos agora vamos adicionar a nossa classe de contexto:

  1: using System;
  2: using System.Collections.Generic;
  3: using System.Linq;
  4: using System.Text;
  5: using System.Data.Entity;
  6: 
  7: namespace WindowsFormsValidacao
  8: {
  9:     public class Contexto : DbContext
 10:     {
 11:         public DbSet<Produto> Produto { get; set; }
 12:     }
 13: }

Agora vamos adicionar os campos em nosso formulário, que ficará desta forma:

image

O TextBox (txtErros) abaixo do botão Salvar é onde iremos mostrar os erros.

Vamos adicionar um DataSource para podermos trabalhar com nossa classe Produto, para isto vá no menu Data/Add New DataSource e escolha Object:

image

Depois escolha a classe produto:

image

Agora você precisa ligar todos os campos TextBox do formulário aos campos da classe. Para fazer isto, clique sobre o TextBox, vá em propriedades/DataBindings/Text e escolha o campo correspondente ao controle. Faça isto para todos os controles:

image

Após o primeiro campo, escolha os campos sempre a partir do bindingsource:

image

Agora vamos ao código do botão incluir, que simplesmente adiciona um novo objeto Produto vinculado a tela:

  1: private void btnNovo_Click(object sender, EventArgs e)
  2:         {
  3:             produtoBindingSource.AddNew();
  4:         }

E por fim vamos ao código que valida os dados e depois insere no BD:

  1:  private void btnSalvar_Click(object sender, EventArgs e)
  2:         {
  3:             var db = new Contexto();
  4:             db.Database.CreateIfNotExists();
  5: 
  6:             var pro = (Produto)produtoBindingSource.Current;
  7:             var erros = pro.Validate();
  8:             if (erros.Count() > 0)
  9:             {
 10:                 txtErros.Text = "";
 11:                 foreach (var err in erros)
 12:                 {
 13:                     txtErros.Text += err + Environment.NewLine;
 14:                 }
 15:             }
 16:             else
 17:             {
 18:                 db.Produto.Add(pro);
 19:                 db.SaveChanges();
 20:                 MessageBox.Show("Produto inserido!");
 21:                 produtoBindingSource.ResetCurrentItem();
 22:             }
 23:         }

Observação: A criação do banco de dados neste ponto é meramente didática, para facilitar o exemplo e não é uma prática recomendável em uma aplicação em produção.

Agora vamos recuperar o produto que está vinculado a tela e logo após vamos chamar o método Validate() que irá retornar a lista de erros que vamos exibir. . Recuperamos o Produto acessando a propriedade Current do BindingSource, mas como ela armazena somente objetos, precisamos converter o valor de Current para o tipo Produto e logo após isto chamamos a validação e caso não exista erros, inserimos o Produto no BD e atualizamos a tela. Os erros são mostrados no campo txtErros na tela.

Você pode formatar a saída do erro modificando o método Validate() na classe ValidacaoEntidade.

Espero que este pequeno exemplo tenha mostrado o quanto é simples fazer validações mesmo em plataformas não tão novas, como o Windows Forms, e isto pode também ser utilizado para validar objetos em camadas separadas da aplicação.

Você pode baixar o código fonte deste exemplo aqui.

Abraços e até a próxima.

Carlos dos Santos.

EntityFramework CodeFirst

No post anterior, eu falei em como trabalhar com Entity Framework usando o Designer, ou seja, um modelo de classes criado a partir de um arquivo EDMX. Este modelo funciona perfeitamente em diversos tipos de projetos, mas o grande incoveniente é ter um arquivo EDMX para cada tipo de banco de dados do seu projeto.

Então vamos agora usar uma abordagem diferente, mas nem tão diferente assim do artigo anterior. Nossa necessidade ainda é manter o isolamento do banco de dados e trabalhar somente com objetos. O CodeFirst, como o próprio nome sugere, nos leva a criar primeiramente as classes POCO e depois o banco de dados, mas é possível também pegar um banco de dados existente e gerar o CodeFirst.

O Entity Framework faz uma ponte entre as classes POCO e o banco de dados utilizando um container que chamamos de Contexto. O contexto é o responsável por mapear as nossas classes com o banco de dados e também por informar ao engine quem é o banco de dados, através da string de conexão, e isto é o que mais me agrada no Code First, você precisa trocar somente a string de conexão para mudar de banco. Nenhum tipo de alteração no código é necessária.

Instalando o Entity Framework Code First:

Antes de começarmos a escrever as classes, precisamos instalar o Entity Framework CodeFirst, que é basicamente composto pela EntityFramework.DLL. Faremos isto isando o NuGet, que é um instalador de pacotes para o Visual Studio. Se você ainda não o possui, vá até o Extension Manager do Visual Studio (Tools/Extension Manager) e instale:

SNAGHTMLa23ac4a_thumb1_thumb

Depois de instalado o NuGet, vá em Tools/Library Package Manager/Package Manager Console. Isto vai abrir o gerenciador do NuGet:

image_thumb1_thumb

Agora digite o comando: Install-Package EntityFramework dentro do console, isto irá instalara o EF CodeFirst e suas dependências:

Criando um projeto com o EntityFramework CodeFirst:

Vamos criar uma classe de contexto que chamaremos de Contexto.cs, esta classe irá herdar de DbContext e nela iremos mapear nossas tabelas:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using System.Data.Entity;

   6:  

   7: namespace EFCodeFirst

   8: {

   9:     public class Contexto : DbContext

  10:     {

  11:         public DbSet<Grupo> Grupo { get; set; }

  12:         public DbSet<Produto> Produto { get; set; }

  13:     }

  14: }

O segredo aqui é o DBSet<>, pois ele faz o mapeamento da nossa classe para o banco e vincula a um objeto, que utilizaremos para fazer as operações com o BD.

Veja o código da classe Grupo:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using System.ComponentModel.DataAnnotations;

   6:  

   7: namespace EFCodeFirst

   8: {

   9:     [Table("Grupo")]

  10:     public class Grupo

  11:     {

  12:         public int ID { get; set; }

  13:         [Required(ErrorMessage="Nome não pode ser branco.")]

  14:         public string Nome { get; set; }

  15:  

  16:         public virtual IQueryable<Produto> Produtos { get; set; }

  17:     }

  18: }

E da classe Produto:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using System.ComponentModel.DataAnnotations;

   6:  

   7: namespace EFCodeFirst

   8: {

   9:     [Table("Produto")]

  10:     public class Produto

  11:     {

  12:         public int ID { get; set; }

  13:         [Required(ErrorMessage="Nome não pode ser branco.")]

  14:         public string Descricao { get; set; }

  15:         public int GrupoID { get; set; }

  16:  

  17:         [ForeignKey("GrupoID")]

  18:         public virtual Grupo Grupo { get; set; }

  19:     }

  20: }

No CodeFirst podemos controlar todos os aspectos do mapeamento das classes com o banco de dados, desde o nome da tabela no banco, obrigatoriedade dos campos, tamanho, etc.

Na classe Grupo, eu determinei o nome da tabela no banco de dados (linha 9), ou seja, podemos ter um nome para a classes e outro para a tabela no banco de dados. Informei também que o nome não pode ser banco e vinculei uma mensagem, que pode ser usada em projetos MVC e WPF (linha 13). Finalmente criei o relacionamento entre Grupo e Produto (linha 16).

Na classe Produto, eu determinei também o nome da tabela no banco de dados, e o campo obrigatório. Fiz também o relacionamento com a tabela grupo através do campo GrupoID (linhas 15 e 17,18).

O EF identifica também automaticamente as chaves primárias das tabelas, desde que você as chame por ID ou nome_da_tabelaID, exemplo: GrupoID ou ProdutoID.

Um coisa muito legal que o EF CodeFirst faz para nós é criar o banco de dados, mas isto depende do provider do seu banco de dados, nem todos aceitam a criação do banco.

Vamos agora montar um exemplo para carregar dados no nosso banco:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5:  

   6: namespace EFCodeFirst

   7: {

   8:     class Program

   9:     {

  10:         static void Main(string[] args)

  11:         {

  12:             var db = new Contexto();

  13:  

  14:             db.Database.CreateIfNotExists();

  15:  

  16:             var g1 = new Grupo() { Nome = "Peças" };

  17:             var g2 = new Grupo() { Nome = "Serviços" };

  18:  

  19:             db.Grupo.Add(g1);

  20:             db.Grupo.Add(g2);

  21:  

  22:             var p1 = new Produto() { Descricao = "Pneu", Grupo = g1 };

  23:             var p2 = new Produto() { Descricao = "Roda", Grupo = g1 };

  24:             var p3 = new Produto() { Descricao = "Alinhamento", Grupo = g2 };

  25:             var p4 = new Produto() { Descricao = "Balanceamento", Grupo = g2 };

  26:  

  27:             db.Produto.Add(p1);

  28:             db.Produto.Add(p2);

  29:             db.Produto.Add(p3);

  30:             db.Produto.Add(p4);

  31:  

  32:             db.SaveChanges();

  33:  

  34:             var dados = from p in db.Produto

  35:                         select p;

  36:  

  37:             foreach (var linha in dados)

  38:             {

  39:                 Console.WriteLine("{0,-30} - {1}", linha.Grupo.Nome, linha.Descricao);

  40:             }

  41:  

  42:         }

  43:     }

  44: }

O código acima cria o nosso banco de dados no SQL, caso ele não exista (linha 14). Após isto eu inseri os dados em Grupo e Produto, mas percebam que eu simplesmente vinculei os objetos, sem me preocupar com as chaves primárias ou estrangeiras, pois o EF resolve isto para nós desde que seu mapeamento esteja correto.

Assim ao final do código temos o banco de dados criado e os dados inseridos. Veja como ficou o banco de dados no Management Studio:

image_thumb3_thumb1

Veja que o nome do banco de dados é o nome da aplicação mais o nome do Contexto, mas podemos resolver isto adicionando um arquivo App.Config e informando os dados do banco, então vamos adicionar um arquivo de configuração ao nosso exemplo e colocar a seguinte linha:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <configuration>

   3:   <connectionStrings>

   4:     <add name ="Contexto" providerName="System.Data.SqlClient" connectionString="data source=(local); initial catalog=ExemploEF; user id=teste; password=teste;"/>

   5:   </connectionStrings>

   6: </configuration>

O nome da string de conexão é o mesmo nome da nossa classe de Contexto. O providerName indica que usamos SQL Server e a string de conexão é padrão de ADO.Net, informando Servidor/Banco de Dados/Usuário. Eu já fiz outro post falando só sobre Gerenciamento de Strings de Conexão.

Executando nosso código novamente o banco chamado EFExemplo será criado e preenchido com os dados.

Visualizando o modelo do CodeFirst:

Mas e se você quiser ver como está ficando seu modelo se você está usando somente código ? Para isto existe o Entity Framework PowerTools que permite visualizar o modelo a partir das classes e também gerar um script para o banco de dados. Vejamos como ver o modelo visual do nosso exempo.

Após instalar o PowerTools, clique com o botão direito do mouse sobre a classe Contexto.cs no seu projeto, irá aparecer um menu de contexto EntityFramework, com várias opções:

image_thumb5_thumb1

A primeira opção é justamente a que mostra o modelo gráfico, vamos vê-lo então:

image_thumb3[1]

Já tenho um banco de dados e quero usar o CodeFirst:

Se você já tiver um banco de dados, o EF PowerTools permite que você faça engenharia reversa e gere o contexto e as classes, para isto clique com o botão direito do mouse em sua Solution no Visual Studio e escolhar Entity Framework no menu:

image_thumb9_thumb1

Esta opção gera todas as classes e relacionamentos do seu modelo, basta informar qual o banco de dados e o servidor na janela abaixo:

SNAGHTMLa560840_thumb1_thumb1

Não se esquece de adicionar o EntityFramework CodeFirst com o NuGet antes de fazer a engenharia reversa.

Quando usar Designer ou CodeFirst:

Esta é um pergunta bem complicada, eu diria que se você usa somente um banco de dados e precisa trabalhar com Stored Procedures é melhor usar o Designer, principalmenet porquê o CodeFirst ainda não suporta procedures nativamente.

Se você quer criar uma aplicação multibanco, de maneira mais rápida e simples através de classes POCO, então o CodeFirst é sua escolha.

Muito importante saber também que o Entity Framework Designer e o CodeFirst são independentes e podem não compartilhar alguns recursos.

Espero que o artigo seja útil para vocês e se assim desejarem façam seus comentários ou sugestões.

Até a próxima,
Carlos dos Santos.

Trabalhando com Entity Framework Designer

Olá pessoal,

Hoje em um desenvolvimento de projeto é muito comum  o programador ter que saber vários comando de bancos de dados (Insert, Delete, Update, Select) para poder desenvolver, além de saber sobre a linguagem de progração. O EntityFramework vem para ajudar nesta tarefa, criando uma correspondência entre as tabelas do banco de dados, o que chamamos de ORM, ou mapeamento Objeto-Relacional.

Existem, basicamente, duas maneiras de se trabalhar com o Entity Framework, usando o Entity Designer ou o Entity Framework Code First. A diferença é simples, no Designer você precisa criar um diagrama do banco de dados visualmente, usando um arquivo EDMX, que deve ser específico para cada banco de dados da sua aplicação, ou seja, para cada banco de dados é necessário usar um arquivo EDMX. Neste artigo vamos vamos criar um modelo visual e analisar seus aspectos.

Mapeando o Banco de dados com o Entity Designer:

Abra o Visual Studio 2010 e crie um projeto no .Net Framework 4 do tipo Console Application, depois vá em adcionar novo item. Você verá a janela abaixo, escolha ADO.Net Entity Data Model:

SNAGHTML9dffcc9

Podemos ainda escolher se iremos nosso modelo a partir de um banco de dados pronto ou em branco:

image

Vamos gerar nosso exemplo a partir do banco de dados NorthWind, escolhendo a opção “Generate from database”. Na tela seguinte crie a conexão para o banco de dados e depois escolha quais tabelas, views ou stored procedures você quer mapear:

SNAGHTML9e3d339

No nosso exemplo ou escolher todas as tabelas, views e stored procedures. Feito isto teremos o modelo visual pronto:

image

Este processo gerou um modelo EDMX, que contém basicamente três partes:

1. Storage Model Content: que contém as informações do banco de dados, como tabelas, tipos dos dados, etc;
2. Conceptual Model Content: contém a definição do modelo, o que você pode ver no diagrama, como as classes, tipos complexos, associações, etc.
3. Mapping Content: faz a ligação entre o Storage e o modelo Conceitual.

O código fonte das classes também faz parte do modelo,dentro do arquivo de Designer:

image

Este arquivo contém o código fonte de todas as classes de nosso modelo. Mas então se eu criar um modelo novo as classes serão geradas novamente ? A resposta é SIM.

Opa, mas então temos um problema, teremos classes duplicadas e como vamos resolver isto ? Com classes POCO, que podem ser independentes do modelo. Para isto faremos algumas pequenas modificações no nosso modelo.

Se você for utilizar somente um banco de dados não precisa trabalhar com classes POCO.

Trabalhando com POCO no Entity Designer:

A primeira coisa que precisamos fazer é desativar a geração de código pelo designer. Isto é simples, basta desligarmos a propriedade Code Generation Strategy do modelo, colocando em none:

image

Agora precisamos adicionar novamente as classes e para isto iremos utilizar um gerador automático de código, que iremos adicionar ao nosso projeto:

SNAGHTML9f0e092

Ao adicionarmos o ADO.Net POCO Entity Generator, dois novos arquivos irão aparecer em nosso projeto: Model1.Context.tt e Model1.tt. Para gerar as classes precisamos abrir cada um deles e colocar o nome do nosso arquivo EDMX, Veja o exemplo:

image

No nosso exemplo ficará assim: string inputFile = @”model1.edmx”. Faça o mesmo no arquivo Model1.tt. Depois de fazer isto salve o arquivo e o nosso projeto ficará assim:

image

Agora temos classes POCO, que são independentes do designer. Se você modificar o designer, assim que salvá-lo as classes serão atualizadas automaticamente.

Agora você pode adicionar um novo EDMX apontando para um outro banco de dados, por exemplo: MySQL ou Oracle, desde que tenham a mesma estrutura logicamente, e você usará as mesmas classes.

Usando o modelo para recuperar os dados:

Vamos agora criar um pequeno código para listar os Products e Categories do nosso modelo, usando LINQ:

   1: var db = new NorthwindEntities();

   2:  

   3:             var dados = from p in db.Products

   4:                         select p;

   5:  

   6:             foreach (var linha in dados)

   7:             {

   8:                 Console.WriteLine("{0,-35} - {1}", linha.ProductName, linha.Categories.CategoryName);

   9:             }


No próximo artigo iremos falar sobre o Entity Framework Code First.

Espero que tenham gostado.

Até a próxima.

Carlos dos Santos.

Entity Framework com Oracle

A Oracle acabou de lancar seu provider nativo para o Entity Framework, a versão ODAC  11.2. Agora você já pode acessar nativamente o Oracle com o EF, facilitando o desenvolvimento através do mapeamento objeto relacional.

Para baixar acesse os links abaixo:

Usando EF com Oracle: http://www.oracle.com/technetwork/issue-archive/2011/11-sep/o51odt-453447.html

Provider 32 bits: http://www.oracle.com/technetwork/topics/dotnet/utilsoft-086879.html

Provider 64 bits: http://www.oracle.com/technetwork/database/windows/downloads/index-090165.html

 

[]s,

Carlos dos Santos.