Fala pessoal, o time do entity framework liberou a versão CTP 3, esta versão é compatível com o visual studio 2010 RC. Ainda não rodei a nova dll nos meus projetos, assim que reparar uma grande mudança ou nova funcionalidade legal registro aqui.
fonte:
http://blogs.msdn.com/adonet/archive/2010/02/18/entity-framework-feature-ctp-3-now-available.aspx
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: }
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
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.
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
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: }
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
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.
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
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:
A classe que serve para o mapeamento deve possuir as seguintes configurações:
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:
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.
Pessoal, vamos ver neste post como possibilitar o uso de lazy loading usando POCOs na versão CTP2 do Entity Framework 4. Vamos usar o projeto disponibilizado no post anterior, basta baixar o exemplo e criar uma nova solução chamada EF4LazyLoading e adicionar todos os projetos.
Após baixar o exemplo vamos mudar algumas coisas apenas para diferenciar do projeto anterior. vamos alterar o nome da classe no arquivo model.cs no projeto Model para EF4LazyLoadingModel, devemos trocar as referências também e não esquecer da string de conexão no arquivo DataContext.cs. Agora temos a solução inicial e podemos ver como funciona o lazyLoading no EF4.
1- Vamos criar uma classe chamada contact no nosso projeto classes
1: public class Contact
2: {
3: public Int32 ContactID { get; set; }
4: public String Name { get; set; }
5: public String Email { get; set; }
6: public String Phone { get; set; }
7: public String Address { get; set; }
8: public Person Person { get; set; }
9: public int PersonID { get; set; }
10: }
2- vamos adicionar uma lista de contatos na classe Person
1: public class Person
2: {
3: public int PersonID { get; set; }
4: public String Name { get; set; }
5: public int Age { get; set; }
6: public String Email { get; set; }
7: public List<Contact> Contacts { get; set; }
8: }
3- Agora vamos gerar um arquivo de configuração para a classe Contact
1: public class ContactConfiguration : EntityConfiguration<Contact>
2: {
3:
4: public ContactConfiguration()
5: {
6: Property(c => c.ContactID).IsIdentity();
7: Property(c => c.Name).IsRequired();
8:
9: //Indicando que o relacionamento possui uma regra(Constraint):O objeto Person possui uma coleção de Contacts
10: //com a seguinte regra: o id de Person deve ser o mesmo id de Person Dentro do objeto Contact
11: Relationship(c => c.Person).FromProperty(p => p.Contacts).HasConstraint((c, p) => c.PersonID == p.PersonID);
12: }
13: }
4- Precisamos alterar o arquivo de configuração de Person, vamos adicionar a seguinte linha
1: //Adicionando um relacionamento entre a coleção de Contacts do objeto Person
2: // e a propriedade Person do Objeto Contact
3: Relationship(p => p.Contacts).FromProperty(c => c.Person);
4:
5:
5- agora vamos adicionar a configuração de Contact no nosso DataContext
1: builder.Configurations.Add(new ContactConfiguration());
Agora nossa infra está pronta. vamos testar o lazyLoading.Para usar o lazyLoading como POCOs precisamos declarar a propriedade que será postergada como virtual e setar a opção LazyLoadingEnabled no Data Context.
6- Declarando a propriedade como virtual, vamos declarar a lista de contacts em Person como virtual
1: public virtual ICollection<Contact> Contacts { get; set; }
7-vamos setar o LazyLoadingEnabled no DataContext
1: public static EF4LazyLoadingModel FactoryDataContext()
2: {
3: String connection = @"Data Source=.\SQLEXPRESS;Initial Catalog=EF4LazyLoadingModel;Integrated Security=SSPI;";
4: var builder = new ContextBuilder<EF4LazyLoadingModel>();
5:
6: //Adicionamos todas as configurações
7: builder.Configurations.Add(new PersonConfiguration());
8: builder.Configurations.Add(new ContactConfiguration());
9:
10: var ctx = builder.Create(new SqlConnection(connection));
11: ctx.ContextOptions.LazyLoadingEnabled = true;
12: return builder.Create(new SqlConnection(connection));
13: }
Vamos rodar nosso exemplo e verificar o lazyLoading em ação
1: public static void Main()
2: {
3: //este método cria um database
4: DataContext.CreateDataBase();
5:
6: //Cadastradando uma pessoa
7: Person p = new Person();
8: p.Name = "Higor";
9: p.Age = 20;
10: p.Email = "higor.crr@gmail.com";
11:
12: var ctx = DataContext.FactoryDataContext();
13: ctx.People.AddObject(p);
14: ctx.SaveChanges();
15:
16: //Adicionando um contato
17: Contact c1 = new Contact();
18: c1.PersonID = p.PersonID;
19: c1.Name = "Higor";
20: c1.Phone = "1111-1111";
21: c1.Email = "higor@mail.com";
22: c1.Address = "RUA ABCD";
23:
24: ctx.Contacts.AddObject(c1);
25: ctx.SaveChanges();
26:
27: ctx = DataContext.FactoryDataContext();
28: var person = ctx.People.FirstOrDefault();
29:
30: //Aqui vamos ter problemas pois Contacts nao está carregado.
31: Console.WriteLine("Exibindo todos os contacts");
32: foreach (var item in person.Contacts)
33: {
34: Console.WriteLine("Name:" + item.Name);
35: }
36:
37: Console.ReadKey();
38:
39: }
Podemos usar uma técnica chamada explicitLoad, desta maneira vamos deixar claro que queremos carregar a lista de Contacts
1: ctx = DataContext.FactoryDataContext();
2: var person = ctx.People.FirstOrDefault();
3:
4: ctx.LoadProperty(person, x => x.Contacts);
5: Console.WriteLine("Exibindo todos os contacts");
6: foreach (var item in person.Contacts)
7: {
8: Console.WriteLine("Name:" + item.Name);
9: }
Então, vocês acharam dificil? isso é o básico.. nos proximos posts vou explicar como funciona o lazyLoading e o motivo pelo qual usamos virtual na propriedade. pra quem quiser se adiantar no assunto vou deixar no final do post uns links.
Links:
http://blogs.msdn.com/adonet/archive/2009/12/22/poco-proxies-part-1.aspx
Fala galera,estou testando algumas novidades do Entity Framework 4 e já posso dizer que estou gostando do que estou vendo.Em breve vou fazer posts com exemplos sobre as novas features,por enquanto vou deixar uns links pra quem quiser ler algo.
Download da versão CTP:
http://www.microsoft.com/downloads/details.aspx?FamilyID=13FDFCE4-7F92-438F-8058-B5B4041D0F01&displaylang=en
Blogs e artigos:
http://blogs.msdn.com/adonet/pages/feature-ctp-walkthrough-code-only-for-the-entity-framework.aspx.
http://devtalk.dk/CommentView,guid,b5d9cad2-e155-423b-b66f-7ec287c5cb06.aspx
http://elegantcode.com/2009/12/15/entity-framework-ef4-generic-repository-and-unit-of-work-prototype/
http://elegantcode.com/2009/12/15/building-a-unity-extension-for-entity-framework-poco-configuration-repository-and-unit-of-work/
http://thedatafarm.com/blog/tags/ef/