Arquivo

Arquivo da Categoria ‘.NET 4.0’

DotNetArchitectsRio

19, abril, 2010
Sem comentários

Oi pessoal, posso dizer que no ultimo sábado tivemos um dos mais importantes eventos de .NET no Rio de Janeiro.O evento assim descrito foi o community launch visual studio 2010, um evento de mais de 8horas sobre as novidades do visual studio 2010 e .NET 4.0. A organização do evento ficou por conta do grupo de arquitetura DotNetArchitects do Rio de Janeiro. A comunidade está ficando bem unida e “atacando” de diversas maneiras, além dos blogs temos Dojos e reuniões(Barchitects e encontros técnicos). Você é um desenvolvedor .NET envolvido com a comunidade? então participe também dos eventos!

 

Grupo on-line de arquitetura
http://groups.google.com.br/group/dotnetarchitects

Coding-Dojo
http://rodrigovidal.net/?tag=dotnetarchitects

Reuniões técnicas e barchitects
http://twitter.com/NetArchitectsRJ

Fique de olho nas urls e nos blogs dos participantes que você vai ficar sabendo de todas as novidades.

 

Author: higor.cesar Categories: .NET 4.0, Carreira Tags:

Entity framework 4: CTP 3 liberado

24, fevereiro, 2010
Sem comentários

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

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

Entity Framework 4: Códigos

8, fevereiro, 2010
Sem comentários

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:

Entity Framework 4: Relacionamento 1 pra 1

2, fevereiro, 2010
Sem comentários

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
Sem comentários

 

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: