Entity Framework 4: auto relacionamento

10, fevereiro, 2010

Pessoal vamos ver como construir um auto relacionamento no Entity Framework 4 + POCOs.

1-Classes

   1: public class Category

   2: {

   3:     public virtual int CategoryId { get; set; }

   4:     public String Name { get; set; }

   5:     public virtual Category Parent { get; set; }

   6:  

   7: }

Classe de categoria que possui uma auto-referencia

 

Pronto! todo o resto do código não é necessário.

2-Configuração

   1: public class CategoryConfiguration : EntityConfiguration<Category>

   2: {

   3:     public CategoryConfiguration()

   4:     {

   5:         Property(p => p.CategoryId).IsIdentity();

   6:     }

   7: }

 

3-DataContext

   1: public class DataContext

   2:     {

   3:  

   4:         public static Model FactoryDataContext()

   5:         {

   6:             String connection = @"Data Source=.\SQLEXPRESS;Initial Catalog=EFv4SelfReference;Integrated Security=SSPI;";

   7:             var builder = new ContextBuilder<Model>();

   8:             builder.Configurations.Add(new CategoryConfiguration());

   9:             return builder.Create(new SqlConnection(connection));

  10:         }

  11:  

  12:         public static void CreateDataBase()

  13:         {

  14:  

  15:             var ctx = FactoryDataContext();

  16:             if (ctx.DatabaseExists())

  17:                 ctx.DeleteDatabase();

  18:             ctx.CreateDatabase();

  19:  

  20:         }

  21:  

  22:     }

 

4-Model

   1: public class Model : ObjectContext

   2: {

   3:     public Model(EntityConnection entityConnection)

   4:         : base(entityConnection)

   5:     {

   6:         DefaultContainerName = "Model";

   7:     }

   8:     public IObjectSet<Category> Categories

   9:     {

  10:         get { return base.CreateObjectSet<Category>(); }

  11:     }

  12: }

5-Exemplo

   1: class Program

   2:    {

   3:        static void Main(string[] args)

   4:        {

   5:            DataContext.CreateDataBase();

   6:            Category category1 = new Category();

   7:            category1.Parent = null;

   8:            category1.Name = "cat1";

   9:            category1.Parent = new Category() { Name = "Parent1" };

  10:  

  11:            Model model = DataContext.FactoryDataContext();

  12:            model.Categories.AddObject(category1);

  13:            model.SaveChanges();

  14:  

  15:            foreach (var category in model.Categories)

  16:            {

  17:                Console.WriteLine("Category Name:" + category.Name + "\n");

  18:                if (category.Parent != null)

  19:                    Console.WriteLine("Parent Name:" + category.Parent.Name + "\n");

  20:                else

  21:                    Console.WriteLine("Parent Name: --");

  22:  

  23:                Console.WriteLine("\n\n");

  24:  

  25:  

  26:            }

  27:  

  28:            Console.ReadKey();

  29:        }

  30:  

  31:  

  32:    }

 

Codigo fonte

Author: higor.cesar Categories: Entity Framework, POCO Tags:

Entity Framework 4: Códigos

8, fevereiro, 2010

Pessoal, ando fazendo muitos posts sobre as funcionalidades do Entity Framework 4(Code Only e POCO ) com exemplos de código. Aqui neste post vou indexar a lista de exemplo que tenho até agora(3-02-2010)

Titulo:Change Tracking Proxy
Descrição: exemplo contendo o controle de alteração/estado de um objeto criado baseado no conceito de POCOs
Post Relacionado:Entity Framework 4:Proxies – parte II
Código para download

Titulo:Data annotations
Descrição: exemplo de utilização de data annotations com EF e MVC2
Post Relacionado:EF4 POCO + Data Annotations + ASP.NET MVC 2.0
Código para download

Titulo:Herança no modelo TPC
Descrição: exemplo de configuração de herança modelo tabela por classe
Post Relacionado:Entity Framework 4:Herança no modelo TPC
Código para download

Titulo:Relacionamento um pra um
Descrição: configuração para construção de relacionamento um pra um
Post Relacionado:Entity Framework 4: Relacionamento 1 pra 1
Código para download

Author: higor.cesar Categories: .NET 4.0, Entity Framework Tags:

T4: Acessando o banco de dados

3, fevereiro, 2010

Templates T4 são largamente usados para acessar o banco de dados e gerar código de acordo com os objetos(tabelas e etc). Vamos ver como podemos acessar o SQLServer usando templates tt.Antes de ver o código precisamos baixar ums dlls

1-Importar os assemblies

   1: <#@ assembly name="Microsoft.SqlServer.ConnectionInfo" #>

   2: <#@ assembly name="Microsoft.SqlServer.Smo" #>

   3: <#@ assembly name="Microsoft.SqlServer.Management.Sdk.Sfc" #>

   4: <#@ assembly name="Microsoft.SqlServer.SqlEnum" #>

   5: <#@ import namespace="System.IO" #>

   6: <#@ import namespace="Microsoft.SqlServer.Management.Smo" #>

2-Estabelecer a conexão

   1: <#

   2:     Server server = new Server("NomeDaMaquina\\NomeDaInstancia");

   3:     Database database = new Database(server, "NomeDoDatabase");

   4:     database.Refresh();

   5: #>

3- Gerando uma classe para cada tabela do banco

   1: <#

   2:     foreach (Microsoft.SqlServer.Management.Smo.Table item in database.Tables)

   3:     {

   4: #>

   5:     public class <#=item.Name#>{}

   6:     <# SaveOutput(item.Name+".cs");

   7:     }

   8: #>

4- Usamos um método SaveOutput que está em outro tt que foi incluido no início do arquivo

   1: <#@ include file="SaveOutput.tt" #>

5- Código do SaveOutput.tt

   1: <#@ template language="C#" hostspecific="true" #>

   2: <#@ import namespace="System.IO" #>

   3: <#+

   4:   void SaveOutput(string outputFileName)

   5:   {

   6:       string templateDirectory = Path.GetDirectoryName(Host.TemplateFile);

   7:       string outputFilePath = Path.Combine(templateDirectory, outputFileName);

   8:       File.WriteAllText(outputFilePath, this.GenerationEnvironment.ToString());

   9:

  10:       this.GenerationEnvironment.Remove(0, this.GenerationEnvironment.Length);

  11:   }

  12: #>

Download do código fonte

Author: higor.cesar Categories: Agile, SQLServer, T4, Uncategorized Tags:

Entity Framework 4: Relacionamento 1 pra 1

2, fevereiro, 2010

Olá pessoal, continuando a serie de posts sobre a versão 4 do entity framework vou mostrar como podemos criar um relacionamento um pra um usando o Code-only e POCOs.

1-Entidades

No exemplo temos duas entidades: Pessoa e Conta bancária. No nosso exemplo uma pessoa possui ou não uma conta bancária

 

   1: public class BankAccount

   2: {

   3:     public virtual int BankAccountID { get; set; }

   4:     public virtual String AccountNumber { get; set; }

   5:     public virtual String BankName { get; set; }

   6:     public virtual Person Person { get; set; }

   7: }

   1: public class Person

   2: {

   3:     public virtual int PersonID { get; set; }

   4:     public virtual String Name { get; set; }

   5:     public virtual String Email { get; set; }

   6:     public virtual BankAccount BankAccount { get; set; }

   7: }

2- Configurações

   1: public class PersonConfiguration : EntityConfiguration<Person>

   2:     {

   3:     public PersonConfiguration()

   4:     {

   5:         Property(p => p.PersonID).IsIdentity();

   6:     }

   7: }

A configuração da classe Person é simples, vamos ver agora como fica a configuração de conta bancária

   1: public class BankAccountConfiguration : EntityConfiguration<BankAccount>

   2: {

   3:     public BankAccountConfiguration()

   4:     {

   5:         Property(ba => ba.BankAccountID).IsIdentity();

   6:  

   7:         //Definimos que existe um relacionamento com person que é requerido

   8:         Relationship<Person>(p => p.Person).FromProperty(b => b.BankAccount).IsRequired();

   9:     }

  10: }

 

Pronto! temos todo o código necessário para o relacionamento um pra um. Quem quiser segue abaixo o link da solução completa.

codigo fonte

Author: higor.cesar Categories: .NET 4.0, Entity Framework Tags:

Entity Framework 4:Herança no modelo TPC

27, janeiro, 2010

 

A versão 1.0 do Entity Framework já disponibilizava o recurso de herança entre entidades. Agora vamos ver como funciona a herança no Entity Framework 4 + POCOs.O exemplo aqui postado foi baseado neste post.

1-Entidades

vamos começar criando as entidades.

   1: public class Person

   2:     {

   3:         public virtual int PersonID { get; set; }

   4:         public virtual String Name { get; set; }

   5:         public virtual String Email { get; set; }

   6:     }

   1: public class AcademicPerson:Person

   2:    {

   3:        public virtual String Enrolment { get; set; }

   4:    }

 

2-Configurações

   1:  

   2:     public class PersonConfiguration : EntityConfiguration<Person>

   3:     {

   4:         public PersonConfiguration()

   5:         {

   6:             Property(p => p.PersonID).IsIdentity();

   7:             MapHierarchy(p => new

   8:             {

   9:                 p.PersonID,

  10:                 p.Name,

  11:                 p.Email,

  12:             }).ToTable("Person");

  13:         }

  14:     }

na configuração da classe base uso o método MapHierarchy para definir um novo tipo e apontar para tabela person

   1: public class AcademicPersonConfiguration : EntityConfiguration<AcademicPerson>

   2:   {

   3:       public AcademicPersonConfiguration()

   4:       {

   5:           MapHierarchy(ap => new

   6:           {

   7:               ap.PersonID,

   8:               ap.Enrolment

   9:           }).ToTable("AcademicPerson");

  10:  

  11:       }

  12:   }

Aqui é necessário mapear apenas a chave e os novos campos

 

Pronto! todo o código pra herança está ai. agora vamos continuar o exemplo para testar.

3-Modelo

   1: public class Model : ObjectContext

   2: {

   3:     public Model(EntityConnection entityConnection)

   4:         : base(entityConnection)

   5:     {

   6:         DefaultContainerName = "Model";

   7:     }

   8:     public IObjectSet<Person> People

   9:     {

  10:  

  11:         get { return base.CreateObjectSet<Person>(); }

  12:  

  13:     }

  14:  

  15: }

Caso você se pergunte onde está o IObjectSet de AcademicPerson vou lhe responder: Não podemos criar um Iobject set quando estamos trabalhando com classes derivadas. vamos obter as entidades derivadas usando o método OfType<T>().

 

4- DataContext

   1: public class DataContext

   2:    {

   3:  

   4:        public static Model FactoryDataContext()

   5:        {

   6:            String connection = @"Data Source=.\SQLEXPRESS;Initial Catalog=EF4Inheritance;Integrated Security=SSPI;";

   7:            var builder = new ContextBuilder<Model>();

   8:            builder.Configurations.Add(new PersonConfiguration());

   9:            builder.Configurations.Add(new AcademicPersonConfiguration());

  10:  

  11:            return builder.Create(new SqlConnection(connection));

  12:        }

  13:  

  14:        public static void CreateDataBase()

  15:        {

  16:  

  17:            var ctx = FactoryDataContext();

  18:            if (ctx.DatabaseExists())

  19:                ctx.DeleteDatabase();

  20:            ctx.CreateDatabase();

  21:  

  22:        }

  23:  

  24:    }

 

5- Exemplo

   1: class Program

   2:    {

   3:        static void Main(string[] args)

   4:        {

   5:            DataLayer.DataContext.CreateDataBase();

   6:            var dbContext = DataContext.FactoryDataContext();

   7:            

   8:            //Criando uma entidade do tipo Person

   9:            var person1 = dbContext.CreateObject<Person>();

  10:            person1.Email = "higor@mail.com";

  11:            person1.Name = "higor";

  12:            dbContext.People.AddObject(person1);

  13:            dbContext.SaveChanges();

  14:  

  15:            // Criando uma entidade do tipo AcademicPerson

  16:            var academicperson1 = dbContext.CreateObject<AcademicPerson>();

  17:            academicperson1.Email = "carlos@mail.com";

  18:            academicperson1.Name = "carlos";

  19:            academicperson1.Enrolment = "123";

  20:            dbContext.People.AddObject(academicperson1);

  21:            dbContext.SaveChanges();

  22:  

  23:            //Exibindo todas as ~entidades do tipo Person

  24:            Console.WriteLine("People\n");

  25:            foreach (var person in dbContext.People)

  26:                Console.WriteLine("Name: " + person.Name + " Email:" + person.Email);

  27:            

  28:            Console.WriteLine("\n");

  29:            //Exibindo todas as en

  30:            Console.WriteLine("AcademicPeople\n");

  31:            foreach (var academicPerson in dbContext.People.OfType<AcademicPerson>())

  32:                Console.WriteLine("Name: " + academicPerson.Name + " Email:" + academicPerson.Email + " Enrolment" + academicPerson.Enrolment);

  33:  

  34:            Console.ReadKey();

  35:        }

  36:    }

 

fonte:

http://www.dotway.se/post/CodeOnly-Inheritance-e28093-TPH-and-MEF.aspx

Author: higor.cesar Categories: .NET 4.0, Entity Framework, POCO Tags:

EF4 POCO + Data Annotations + ASP.NET MVC 2.0

13, janeiro, 2010

Olá pessoal, nos ultimos posts andei falando bastando sobre o Entity Framework 4 CTP2. Estou realmente empolgado com a galera do EF e a API Code-Only. Eu sempre achei a idéia de usar data annotations muito legal, ainda mais depois que vi como a coisa funciona muito bem com o ASP.NET MVC.

O ASP.NET MVC possui uma integração que possibilita a validação client-side e server-side de uma maneira bem facil. Eu sempre usei LINQ e EF nos meus projetos, sempre com a ferramenta de geração automática de entidades estas ferramentas de geração de código dificultam o trabalho de quem quer usar data annotations. Agora com a API Code-Only tudo se encaixa perfeitamente! estou pensando em mudar a infra do meu projeto e utilizar EF4 POCO+Data annotations+MVC 2. Vamos ver um exemplo de como as coisas funcionam, vou exibir apenas a integração, você pode obter a solução completa no link de download no final do post.

 

   1: public class Contact

   2: {

   3:     public int ContactID { get; set; }

   4:     

   5:     [Required(ErrorMessage="O nome deve ser preenchido"), StringLength(100)]

   6:     public String Name { get; set; }

   7:     

   8:     [Required(ErrorMessage="O e-mail deve ser preenchido")]

   9:     public String Email { get; set; }

  10:     

  11:     public String Phone { get; set; }

  12: }

Classe code-only com as configurações usando Data annotations

 

 

   1: [AcceptVerbs(HttpVerbs.Post)]

   2: public ActionResult Create([Bind(Exclude = "ID")] Contact contact)

   3: {

   4:     try

   5:     {

   6:         

   7:         if (!ModelState.IsValid)

   8:             return View();

   9:   

  10:  

  11:         return RedirectToAction("Index");

  12:     }

  13:     catch

  14:     {

  15:         return View();

  16:     }

  17: }

Ação responsável pela criação
 
 
 
 
   1: public ActionResult Create([Bind(Exclude = "ID")] Contact contact)

Estamos falando que ID não precisa ser carregado.

 

 

O código abaixo é o código da view create.

<%@ Import Namespace="DataLayer.Entities" %>

<%@ Page Title="" Language="C#" MasterPageFile="~/Views/Shared/Site.Master" Inherits="System.Web.Mvc.ViewPage<DataLayer.Entities.Contact>" %>

<asp:Content ID="Content1" ContentPlaceHolderID="TitleContent" runat="server">    Create</asp:Content><asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">    <script src="../../Scripts/jquery-1.3.2.min.js" type="text/javascript"></script>
   1:  

   2:     <script src="../../Scripts/jquery.validate.min.js" type="text/javascript">

   1: </script>

   2:     <script src="../../Scripts/MicrosoftMvcJQueryValidation.js" type="text/javascript">

</script>
<h2>
Contato</h2>
<%

   1:  Html.EnableClientValidation(); 

%>
<%

   1: = Html.ValidationSummary() 

%>
<%

   1:  using (Html.BeginForm())

   2:        {

%>
<%

   1: =Html.EditorForModel() 

%>
<p>
<input type="submit" value="Save" />
</p>
<%

   1:  } 

%>
<div>
<%

   1: =Html.ActionLink("Back to List", "Index") 

%>
</div>
</asp:Content>

 

A validação client-side está na seguinte parte:

<script src="../../Scripts/jquery-1.3.2.min.js" type="text/javascript"></script>
   1:  

   2:   <script src="../../Scripts/jquery.validate.min.js" type="text/javascript">

   1: </script>

   2:   <script src="../../Scripts/MicrosoftMvcJQueryValidation.js" type="text/javascript">

</script>

 

<%
   1:  Html.EnableClientValidation(); 

%>

 

A integração é muito simples! o código completo está abaixo

 

código fonte

Author: higor.cesar Categories: Entity Framework, MVC Tags:

Entity Framework 4:Proxies – parte II

12, janeiro, 2010

Olá pessoal, este é o segundo post falando sobre proxies no Entity Framework 4 CTP2. Desta vez vamos falar sobre o Change Tracking Proxy, este proxy é a nova opção do EF para manter o controle das alterações sofridas por um objeto.

   1: public class Contact

   2: {

   3:     public virtual Int32 ContactID { get; set; }

   4:     public virtual String Name { get; set; }

   5:     public virtual String Email { get; set; }

   6:     public virtual String Phone { get; set; }

   7:     public virtual String Address { get; set; }

   8:     public virtual Person Person { get; set; }

   9:     public virtual int PersonID { get; set; }

  10: }

Nós vimos este tipo de código no LazyLoading. Na parte I vimos que um requisito do Change TrackingProxy é a definição de todas as propriedades como virtuais.

 

Quando usamos este tipo de proxy uma nova entidade é criada em Runtime, esta entidade possui a mesma interface do nosso tipo, fazendo com que não seja necessário identificar se estamos usando ou não o proxy.

Image1

O tipo do objeto é composto da keyword DynamicProxies_TipoDoObjeto_Hash de identificação do objeto de contexto.

Quando usamos este tipo de proxy todas as ações do objeto mapeado são interceptadas pelo o EF que mantém o histórico e integridade do mesmo. No exemplo acima a criação do objeto foi realizada com o método CreateObject do objeto context.

 

   1: Contact c1 = ctx.CreateObject<Contact>();

   2: c1.PersonID = p.PersonID;

 

Quando estamos trabalhando com este tipo de proxy não podemos instanciar os objetos manualmente, uma opção de prevenção é declarar o construtor do tipo como privado.

 

Este excelente post do ADO.NET Team contém vários métodos que podem ser usados com o change tracking proxy

 

Download do codigo fonte

Author: higor.cesar Categories: Entity Framework Tags:

T4: Gerando vários arquivos

8, janeiro, 2010

Quando usamos T4 pode ser necessário gerar vários arquivos com um uníco template, um exemplo clássico é quando estamos gerando o mapeamento para as tabelas do SGBD. Neste post vamos ver um exemplo de como gerar vários arquivos usando templates T4. O exemplo é baseado no post do Oleg.

A função que vamos usar fica no arquivo SaveOutput.tt

 

   1: <#@ template language="C#" hostspecific="true" #>

   2: <#@ import namespace="System.IO" #>

   3: <#+

   4:   void SaveOutput(string outputFileName)

   5:   {

   6:       string templateDirectory = Path.GetDirectoryName(Host.TemplateFile);

   7:       string outputFilePath = Path.Combine(templateDirectory, outputFileName);

   8:       File.WriteAllText(outputFilePath, this.GenerationEnvironment.ToString()); 

   9:  

  10:       this.GenerationEnvironment.Remove(0, this.GenerationEnvironment.Length);

  11:   }

  12: #>

 

Para gerar multiplos arquivos vamos importar o SaveOutput.tt no arquivo exemple1.tt

   1: <#@ include file="SaveOutput.tt" #>

   2:     File 1

   3: <#

   4:     SaveOutput("File1.txt");  #>

   5:    File 2

   6:   <#

   7:     SaveOutput("File2.txt");  #>

 

As informações como nome do arquivo e extensão podem ser alterados de acordo com a sua necessidade.Para visualizar os arquivos clique na opção show all files no solution explorer do visual studio.

 

No proximo post vou mostrar como acessar sua base de dados usando templates T4.

 

Download

Author: higor.cesar Categories: T4 Tags:

T4: Recursos e Links

6, janeiro, 2010

Pessoal, continuando com os estudo sobre T4 achei muitos links legais com ferramentas e tutoriais. vou deixar aqui pra vocês

Editor tangible T4

Este editor é integrado ao visual studio, torna o trabalho de edição muito mais legal.

PreviewT4Editor Download

 

T4 ToolBox

Prove uma série de templates prontos para serem usados além de extensões  para o visual studio, pode ser usado tanto com VB quanto C#. Muito bom pra quem quer geral código LINQ ou EF.

Download

 

Tutoriais e posts

http://www.hanselman.com/blog/T4TextTemplateTransformationToolkitCodeGenerationBestKeptVisualStudioSecret.aspx
http://www.olegsych.com/2007/12/text-template-transformation-toolkit/
http://msdn.microsoft.com/en-us/library/bb126445.aspx

Author: higor.cesar Categories: T4, visual Studio Tags:

Entity Framework 4:Proxies – parte I

6, janeiro, 2010

Olá pessoal,no ultimo post da série sobre o Entity Framework 4 nós falamos sobre LazyLoading. Hoje o assunto será os diferentes tipos de proxies.

O EF 4 possui dois tipos de proxies, são eles:

  • LazyLoading proxy
  • Change Tracking proxy

A classe que serve para o mapeamento deve possuir as seguintes configurações:

  • Deve ser publica e não possuir a keywork sealed
  • Deve possuir um construtor sem parâmetros publico ou privado
  • Deve possuir propriedades publicas ou protegidas

LazyLoadingProxy

Este tipo de proxy é utilizado quando queremos usar lazyLoading em determinadas propriedades.Para este tipo de proxy funcionar basicamente precisamos habilitar o lazy Loading no Data Context e declarar a propriedade como virtual, e caso seja uma coleção a preferência é Icollection.

ctx.ContextOptions.LazyLoadingEnabled = true;
public virtual ICollection<Contact> Contacts { get; set; }

 

Change Tracking Proxy

Este tipo de proxy é o mais legal, pois a função dele é controlar as alterações nos objetos mapeados pelo EF.

Snapshot

O padrão de controle de alteração é conhecido como snapshot, este processo é assim chamado pois a cada query realizada uma cópia dos  valores do objeto é realizada.Quando chamamos um método para salvar as alterações uma comparação entre o estado atual e os snapshots é realizada. Este mecanismo pode levar ao armazenamento de muitos snapshots fazendo com que a memoria fique cheia.

 

Proxies

Quando o change tracking proxy é usado o objeto notifica diretamente o ObjectStateManager. Os proxies funcionam interceptando as alterações no objeto, para isso alguns passos devem ser seguidos:

  1. Todas as propriedades mapeadas devem ser declaradas virtuais e com escopo público ou protegido
  2. Coleções devem ser do tipo Icollection e devem possuir get e set

quando utilizamos este tipo e proxy um objeto é criado em tempo de execução, este objeto criado possui a mesma interface do objeto mapeado e outros membros para habilitar o change Tracking.

Usar este tipo de proxy possui algumas peculiaridades como a instanciação de um novo objeto ou até comparação de tipos visto que o objeto gerado possui apenas a mesa interface do objeto mapeado.

O proximo post será um exemplo de uso do Change Tracking proxy, quem quiser saber mais pode olhar aqui.

Author: higor.cesar Categories: Entity Framework Tags: