[EntityFramework] Configurando una relación de uno a muchos en Code First

En el artículo anterior vimos cómo configurar una relación de uno a uno en Code First usando Data Annotations y Fluent Api, en esta ocasión vamos a ver cómo configurar una relación de uno a muchos usando las mismas entidades de dominio Producto y Categoria.

Relación de uno a muchos mediante Data Annotations:

Nuestra entidad Producto será de la siguiente forma:

    [Table("Productos")]
    public class Producto
    {
        [Key]
        public int Codigo { get; set; }
 
        [Required]
        [Column("Nombre", TypeName = "varchar", Order = 2)]
        public string Nombre { get; set; }
 
        [MaxLength(100), MinLength(10)]
        public string Descripcion { get; set; }
 
        [NotMapped]
        public string CodigoIso { get; set; }
 
        [ForeignKey("Categoria")]
        public int IdCategoria { get; set; }
 
        public virtual Categoria Categoria { get; set; }
    }

Cómo ven agregamos IdCategoria y especificamos que se trata de la clave foránea con respecto a la entidad categoria, de igual forma agregamos la propiedad Categoria de tipo Categoria que representa la relación, y a continuación en nuestra entidad Categoria agregaremos una colección de tipo Producto para indicar que una categoría puede tener uno o muchos productos:

    public class Categoria
    {
        [Key]
        public int Id { get; set; }
 
        [MaxLength(100)]
        public string Nombre { get; set; }
 
        [MaxLength(200)]
        public string Descripcion { get; set; }
 
        [Required]
        public virtual ICollection<Producto> Producto { get; set; }
    }

Y con esto tenemos configurada nuestra relación de una a muchos entre Productos y Categorías a través de Data Annotations, ahora para probar la configuración podemos crear una app de consola y copiar el siguiente código en la clase program:

    class Program
    {
        static void Main(string[] args)
        {
            var categoria = new Categoria { Id = 1, Nombre = "Lacteos", Descripcion = "Productos lacteos" };
            var producto = new Producto { Codigo = 1, Nombre = "Leche", Descripcion = "Producto Lacteo", Categoria = categoria };
            var producto2 = new Producto { Codigo = 2, Nombre = "Queso", Descripcion = "Producto Lacteo", Categoria = categoria };
            using (var contexto = new Context())
            {
                contexto.Productos.Add(producto);
                contexto.Productos.Add(producto2);
                contexto.SaveChanges();
            }
        }
    }

Relación de uno a muchos mediante Fluent Api:

Ahora vamos a configurar la relación de uno a muchos entre Productos y Categorías, pero esta vez vamos a usar Fluent Api para lograrlo:

    public class Context : DbContext
    {
        public Context() : base("Productos")
        {
            
        }
 
        public DbSet<Producto> Productos { get; set; }
 
        public DbSet<Categoria> Categorias { get; set; }
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            // Aquí haremos nuestras configuraciones con Fluent API.
 
            modelBuilder.Configurations.Add(new ProductoMappings());
 
            modelBuilder.Entity<Producto>()
                .HasRequired<Categoria>(c => c.Categoria)
                .WithMany(c => c.Productos)
                .HasForeignKey(c => c.IdCategoria);
 
            base.OnModelCreating(modelBuilder);
        }
    }

Cómo vemos en el método OnModelCreating especificamos la relación a través de Fluent Api, dónde indicamos la relación partiendo la entidad Producto e indicamos el WithMany con Categoría.

Y bueno amigos, eso es todo, espero les sea de utilidad y de interés este post acerca de relación uno a muchos en Entity Framework code First, en el próximo artículo observaremos cómo configurar una relación de muchos a muchos, para terminar con el tema de relaciones y seguir con otros temas.

Saludos y buena suerte!

[EntityFramework] Configurar una relación uno a uno en Code First

En artículos anteriores, vimos cómo configurar nuestras entidades de dominio a través de Data Annotations y a través de Fluent Api, ahora vamos a ver cómo configurar diferentes relaciones en la base de datos mediante estas dos alternativas, en primera instancia vamos a ver cómo configurar una relación de uno a uno entre las entidades Producto y Categoria.

Relación de uno a uno mediante Data Annotations:

Nuestra entidad Categoria será de la siguiente forma:

    public class Categoria
    {
        public int Id { get; set; }
 
        [MaxLength(100)]
        public string Nombre { get; set; }
 
        [MaxLength(200)]
        public string Descripcion { get; set; }
 
        [Required]
        public virtual Producto Producto { get; set; }
    }

Entonces para nuestro ejemplo supondremos que un producto solo puede tener una categoría, y para configurar la relación a través de Data Annotations hacemos lo siguiente:

    [Table("Productos")]
    public class Producto
    {
        [Key]
        public int Codigo { get; set; }
 
        [Required]
        [Column("Nombre", TypeName = "varchar", Order = 2)]
        public string Nombre { get; set; }
 
        [MaxLength(100), MinLength(10)]
        public string Descripcion { get; set; }
 
        [NotMapped]
        public string CodigoIso { get; set; }
 
        [ForeignKey("Categoria")]
        public int IdCategoria { get; set; }
 
        public virtual Categoria Categoria { get; set; }
    }

Como podemos ver en nuestra entidad Producto creamos una propiedad de tipo entero llamada IdCategoria, y la decoramos con el atributo ForeignKey el cual nos indica que esta propiedad nos servirá para relacionarla con otra entidad, y vemos que en su constructor especificamos la palabra "Categoria", que hace alusión a la propiedad virtual que nos sirve para configurar la relación con la entidad Categoria, de esta forma una vez se cree la base de datos se creara la relación de uno a uno.

Para probar esto podemos crear una aplicación de consola y escribir el siguiente código en la clase Program:

    class Program
    {
        static void Main(string[] args)
        {
            var categoria = new Categoria { Id = 1, Nombre = "Lacteos", Descripcion = "Productos lacteos" };
            var producto = new Producto { Codigo = 1, Nombre = "Leche", Descripcion = "Producto Lacteo", Categoria = categoria };
            using (var contexto = new Context())
            {
                contexto.Productos.Add(producto);
                contexto.SaveChanges();
            }
        }
    }

Y observaremos que tan sólo agregando el producto a la base de datos también se agregara la categoría correspondiente en su respectiva tabla y con sus relaciones correspondientes. Ahora vamos a ver como lo podemos hacer pero esta vez usando Fluent Api.

Relación de uno a uno mediante Fluent Api:

Para configurar la relación a través de Fluent Api, creamos una clase de configuración para la entidad Categoria o lo hacemos directamente en el contexto como vimos en el artículo Configurando nuestras entidades de dominio con Fluent Api:

    public class CategoriaMappings : EntityTypeConfiguration<Categoria>
    {
        public CategoriaMappings()
        {
            // Crear relación con la entidad Producto.
            this.HasRequired(c => c.Producto).WithRequiredPrincipal(e => e.Categoria);
        }
    }

Como vemos homologamos el código planteado anteriormente con Data Annotations, indicando que en la entidad categoría se requiere un producto y de igual forma en la entidad productos se requiere una categoría.

Y bueno amigos, eso es todo, espero les sea de utilidad y de interés este post acerca de relación uno a uno en Entity Framework code First, en próximos artículos observaremos cómo configurar otros tipos de relaciones.

Saludos y buena suerte!

[EntityFramework] Configurando nuestras entidades de dominio con Fluent API

Cómo apreciamos en nuestro artículo anterior Configurando nuestras entidades de dominio con Data Annotations logramos configurar nuestras entidades de dominio a través de Data Annotations, con esto logramos definir características particulares de entidades y propiedades a la hora de ser mapeadas para la creación de la base de datos, esta es una forma de hacerlo, pero no la única que nos brinda Entity Framework Code First. En este artículo vamos a ver cómo podemos hacer lo mismo pero esta vez usaremos Fluent API, que nos permite hacer este tipo de configuraciones de una forma centralizada, teniendo acceso a cada entidad que tengamos en nuestro contexto y usando métodos encadenados y expresiones lambda para realizar la configuración.

Ahora vamos a implementar la misma configuración del ejemplo anterior dónde usamos Data Annotations, con Fluent API para que podamos comparar más fácil cómo es el trabajo con cada una, y en base a esto tomar una elección personal de cuál usar.

Lo primero que debemos hacer para usar Fluent Api, es sobre escribir el método OnModelCreating de nuestro contexto, ya con esto al interior de este método podremos realizar las configuraciones sobre las entidades, tal y cómo se muestra a continuación:

    public class Context : DbContext
    {
        public Context() : base("Productos")
        {
            
        }
 
        public DbSet<Producto> Productos { get; set; }
 
        public DbSet<Categoria> Categorias { get; set; }
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            // Aquí haremos nuestras configuraciones con Fluent API.
            base.OnModelCreating(modelBuilder);
        }
    }

Cómo vemos ahora el método OnModelCreating recibe el parámetro modelBuilder de tipo DbModelBuilder, es con esta clase que lograremos hacer todas las configuraciones que necesitamos, ahora sí vamos a ver como lograr dichas configuraciones, las cuales haremos sobre la entidad Producto, la cual usamos en nuestro ejemplo anterior de Data Annotations:

    [Table("Productos")]
    public class Producto
    {
        [Key]
        public int Codigo { get; set; }
 
        [Required]
        [Column("Nombre", TypeName = "varchar", Order = 2)]
        public string Nombre { get; set; }
 
        [MaxLength(100), MinLength(10)]
        public string Descripcion { get; set; }
 
        [NotMapped]
        public string CodigoIso { get; set; }
    }

Ahora homologaremos todo lo que hicimos con Data Annotations a través de Fluent Api, de la siguiente manera:

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            // Aquí haremos nuestras configuraciones con Fluent API.
 
            // Especificar el nombre de una tabla.
            modelBuilder.Entity<Producto>().Map(m => m.ToTable("Productos"));
 
            // establecer una primary key.
            modelBuilder.Entity<Producto>().HasKey(c => c.Codigo);
 
            // Definir un campo como requerida.
            modelBuilder.Entity<Producto>().Property(c => c.Nombre).IsRequired();
 
            // Definir el nombre de un campo.
            modelBuilder.Entity<Producto>().Property(c => c.Nombre).HasColumnName("Nombre");
 
            // Definir el tipo de un campo.
            modelBuilder.Entity<Producto>().Property(c => c.Nombre).HasColumnType("varchar");
 
            // Definir el orden de un campo.
            modelBuilder.Entity<Producto>().Property(c => c.Nombre).HasColumnOrder(2);
 
            // Definir el máximo de caracteres permitidos para un campo.
            modelBuilder.Entity<Producto>().Property(c => c.Descripcion).HasMaxLength(100);
 
            // indicar que no se debe mapear una pripiedad a la base de datos.
            modelBuilder.Entity<Producto>().Ignore(c => c.CodigoIso);
 
            base.OnModelCreating(modelBuilder);
        }

Como podemos ver, hemos homologado las instrucciones de primary key, nombres, requerido y demás características a través de Fluent Api, con esto podríamos quitar los Data Annotations de nuestra entidad de dominio Producto, y una vez se inicialice la base de datos se tendrán en cuenta las configuraciones especificadas en el método OnModelCreating.

Para terminar con el artículo quisiera darles un tip, para el trabajo con Code First Fluent Api, de una forma más ordenada, ya que como vemos la codificación en el método OnModelCreating puede crecer bastante ya que allí va la configuración para cada entidad, por esto una buena práctica es separar en clases la configuración de cada entidad, con esto logramos un código más ordenado y más reutilizable, ahora veamos cómo hacerlo:

Para esto sólo debemos crear una clase que herede de EntityTypeConfiguration<T> y en el constructor de esta clase codificar las configuraciones tal y como lo hicimos en el método OnModelCreating, cómo se muestra a continuación:

    public class ProductoMappings : EntityTypeConfiguration<Producto>
    {
        public ProductoMappings()
        {
            // Especificar el nombre de una tabla.
            this.Map(m => m.ToTable("Productos"));
 
            // establecer una primary key.
            this.HasKey(c => c.Codigo);
 
            // Definir un campo como requerida.
            this.Property(c => c.Nombre).IsRequired();
 
            // Definir el nombre de un campo.
            this.Property(c => c.Nombre).HasColumnName("Nombre");
 
            // Definir el tipo de un campo.
            this.Property(c => c.Nombre).HasColumnType("varchar");
 
            // Definir el orden de un campo.
            this.Property(c => c.Nombre).HasColumnOrder(2);
 
            // Definir el máximo de caracteres permitidos para un campo.
            this.Property(c => c.Descripcion).HasMaxLength(100);
 
            // indicar que no se debe mapear una pripiedad a la base de datos.
            this.Ignore(c => c.CodigoIso);
        }
    }

Haríamos estos para cada entidad, y en el método OnModelCreating sólo agregaríamos la configuración que acabamos de crear, de la siguiente forma:

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            // Aquí haremos nuestras configuraciones con Fluent API.
 
            modelBuilder.Configurations.Add(new ProductoMappings());
 
            base.OnModelCreating(modelBuilder);
        }

Y para despedirme quisiera anotar que un método de configuración no excluye al otro, es decir podríamos usar configuración a través de Data Annotations y también a través de Fluent Api sin ningún problema. Y bueno eso es todo espero les sea de utilidad y de interés este tema de configuración de entidades de dominio a través de Entity Framework Code First Fluent Api.

Saludos y buena suerte!

[EntityFramework] Configurando nuestras entidades de dominio con Data Annotations

En nuestro artículo anterior Creando nuestra base de datos, basados en nuestro contexto surgieron algunas interrogantes acerca de cómo establecer la longitud máxima para nuestros campos en la base de datos, o cómo darles un nombre diferente al de la propiedad, o cómo darles un tipo en específico, o cómo especificar si permiten valores nulos o no, o cómo crear relaciones entre las tablas, entre otras interrogantes que pueden surgir, pero bueno en este artículo vamos a ver cómo podemos lograr este tipo de cosas a través de Data Annotations, que no son más que atributos con los cuales podemos decorar nuestras entidades y propiedades para que tengan ciertas características, para quienes han trabajado con Asp.Net MVC funciona de igual forma que los Data Annotations que podemos usar para los modelos y de hecho hay unas en común para EF y MVC cómo por ejemplo el atributo Required que indica si una propiedad es requerida o no. Cómo vimos en nuestro artículo anterior para una configuración básica no es necesario usar Data Annotations ya que Entity Framework Code First trabaja con convención sobre la configuración, es decir las clases que sigan con la convención que propone EF serán mapeadas sin problemas, de lo contrario se debe usar Data Annotations o Fluent API para establecer la configuración. Ahora veamos algunos ejemplos de cómo configurar nuestras entidades de dominio usando Data Annotations, para esto usaremos las entidades de dominio del artículo anterior.

Para crear relaciones entre tablas y por normalización de base de datos cada tabla debe tener una clave primaria que la identifique únicamente, como vimos en el ejemplo anterior nuestras entidades tienen un campo llamado Id, y es por esto que cuando se generó la tabla en la DB se creó este campo como primary key, y es a esto cuando me refería a convención sobre la configuración, en este caso por ejemplo EF busca en la entidad un campo que se llame Id o que contenga esta palabra y a través de esta convención sabe que este campo será la clave primaria de la tabla, y por eso decía anteriormente también que si no se cumplían con las convenciones se debería usar Data Annotations o Fluent API para el configurar, por ejemplo si en mi siguiente entidad mi clave primaria será el campo Codigo que cómo vemos no contiene la palabra Id debemos usar el atributo [Key] para especificarla explícitamente:

    [Table("Productos")]
    public class Producto
    {
        [Key]
        public int Codigo { get; set; }
 
        [Required]
        [Column("Nombre", TypeName = "varchar", Order = 2)]
        public string Nombre { get; set; }
 
        [MaxLength(100), MinLength(10)]
        public string Descripcion { get; set; }
 
        [NotMapped]
        public string CodigoIso { get; set; }
    }

Cómo podemos ver decoramos la propiedad Codigo con el atributo [Key] con esto le estamos diciendo a Entity Framework que esta será la clave primaria de la tabla, y podemos ver una serie de atributos que hemos usado y que explicare a continuación:

[Table("Productos")] : Permite asignar un nombre en específico a la tabla que se generará a partir de la entidad, recordemos que si no se usa este atributo Entity Framework asume que el nombre de la tabla será el plural del nombre de la entidad por ejemplo para la entidad Producto su tabla correspondiente recibirá el nombre de Productos.

[Required] : Permite indicar si un campo es requerido o no, es decir si el campo en la tabla permitirá valores nulo o no, lo que conocemos como Null o Not Null.

[Column] : Se usa para indicar información correspondiente a una columna de la tabla, su constructor posee dos sobre cargas en las cuales podemos especificar nombre de la columna en caso de que queramos especificar un nombre diferente al de la propiedad de la entidad, tipo de la columna y orden en el que aparecerá en la tabla.

[MaxLength] : especifica la longitud máxima del campo en la base de datos.

[MinLength] : especifica la longitud mínima del campo en la base de datos.

[NotMapped] : Puede darse el caso que por algún motivo no deseemos mapear alguna propiedad de alguna entidad de dominio a nuestra base de datos ya que solo la queremos tener en nuestra entidad para usarla en nuestra lógica y no queramos persistir la propiedad a la base de datos. Este atributo nos ayuda con esto, cuando EF encuentre alguna propiedad decorada con este atributo simplemente la omitirá y no la tendrá en cuenta para la creación de la DB.

Bueno y con esto damos por terminado nuestro artículo de como configurar nuestras entidades de dominio a través de Data Annotations. Cómo mencione antes existe otra forma de hacer la configuración y es a través de Fluent Api, tema que trataremos en el próximo artículo de esta serie de Entity Framework Code First, espero les sea de interés y utilidad.

Para observar todos los Data Annotatiosn disponibles revisar la documentación del name space System.ComponentModel.DataAnnotations

Saludos y buena suerte!

[EntityFramework] Creando nuestra base de datos, basados en nuestro contexto

Luego de ver en nuestro anterior artículo Iniciando con Code First una introducción y un acercamiento a Entity Framework Code First, y de comprender su filosofía de trabajo, ahora vamos a ver cómo es su implementación y forma de trabajo, para esto vamos a iniciar con la creación de nuestras entidades de dominio las cuales nos servirán para toda nuestra serie de artículos de este enfoque de EF, y luego crearemos nuestro contexto, el cual como ya sabemos nos servirá para interactuar con nuestra base de datos.

En primera instancia vamos a crear dos entidades de dominio, las cuales en un escenario real de utilización de EF Code First podríamos partir de que dichas entidades ya existen, nuestras entidades serán Producto y Categoría y las vamos a crear dentro de un proyecto de tipo librería de clases el cual recibirá el nombre de Dominio.

   1:  public class Producto

   2:  {

   3:      public int Id { get; set; }

   4:   

   5:      public string Nombre { get; set; }

   6:   

   7:      public string Descripcion { get; set; }

   8:  }

   1:  public class Categoria

   2:  {

   3:       public int Id { get; set; }

   4:   

   5:       public string Nombre { get; set; }

   6:   

   7:       public string Descripcion { get; set; }

   8:  }

Perfecto esas clases tan simples serán las entidades de dominio con las que trabajaremos en nuestro ejemplo, ahora vamos a habilitar estas entidades para que a través de ellas podamos en primera instancia crear nuestra base de datos y posteriormente interactuar entre dominio y DB mediante el mapeo generado, para esto creamos un contexto el cual contenga propiedades de tipo DBSet<T> para cada entidad:

   1:  class Context : DbContext

   2:  {

   3:       public Context() : base("Productos")

   4:       {

   5:              

   6:       }

   7:   

   8:       public DbSet<Producto> Productos { get; set; }

   9:   

  10:       public DbSet<Categoria> Categorias { get; set; }

  11:  }

Y listo, con esto tenemos una infraestructura básica para lograr crear nuestra base de datos basados en las entidades de dominio que creamos, un aspecto a tener en cuenta en el contexto que acabamos de crear es que estamos pasando como parámetro al constructor el nombre que va a tener nuestra base de datos, y es importante especificar la cadena de conexión en el archivo app.config de nuestro proyeto, para tener los datos de conexión al servidor:

   1:  <connectionStrings>

   2:      <add name="ProductosDBConnectionString"

   3:      connectionString="Data Source=TAVOPC\SQLEXPRESS;Initial   Catalog=Productos;Integrated Security=true;"

   4:      providerName="System.Data.SqlClient"/>

   5:  </connectionStrings>

Y para terminar con nuestro ejemplo, vamos a crear en nuestra solución (.sln) un proyecto de tipo consola, en el cual probaremos si funciona correctamente nuestro contexto, para esto agregamos la referencia a nuestro proyecto de dominio, para poder acceder al contexto, hacemos el respectivo using y por ultimo copiamos este fragmento de código en el método main de la clase Program de nuestro proyecto de consola:

   1:  class Program

   2:  {

   3:          static void Main(string[] args)

   4:          {

   5:              using (var contexto = new Context())

   6:              {

   7:                  var producto = new Producto {Id = 1, Nombre = "Jabón", Descripcion = "Producto para el aseo del hogar" };

   8:                  contexto.Productos.Add(producto);

   9:                  contexto.SaveChanges();

  10:              }

  11:          }

  12:  }

Ahora ejecutamos para probar, y efectivamente vemos que se ha creado nuestra base de datos, con el nombre que indicamos en el constructor, tal cual con la estructura de nuestra entidades y además se ha agregado el producto que indicamos en la tabla Productos, como podemos observar si depuramos la primer vez que ejecutamos la app se demora un tiempo considerable en agregar el producto ya que en ese momento no existe la Db y por lo tanto se crea, pero en las ejecuciones que hagamos en adelante el tiempo será muy corto.

Bueno y con esto damos por terminado nuestro ejemplo de cómo crear nuestra base de datos basados en un contexto previamente creado, sin embargo surgen algunas dudas como: ¿Cómo se logran crear relaciones de diferentes tipos entre las tablas? ¿Cómo doy longitud a los campos de la tabla y demás características? pues bien en próximos artículos iremos profundizando y explicando estos temas, espero les sea de utilidad.

Saludos y buena suerte!

[EntityFramework] Iniciando con Code First

Otro de los enfoques que nos ofrece Entity Framework es Code First, este es un enfoque en el cual se deja a un lado el diseñador de modelo y con ello toda su facilidad visual de la que hablamos en nuestra serie de artículos anteriores Enfoque Data Base First, sin embargo nos ofrece como los otros enfoques grandes ventajas si lo usamos en el escenario adecuado y un buen punto de referencia para saber si se trata del escenario adecuado es ¿Qué enfoque elegir?

En Code First primero codificamos y luego generamos nuestra base de datos en base al código que hemos creado, un poco en contra de lo que estamos acostumbrados no? ya que por lo general modelamos en primera instancia y luego implementamos, sin embargo, puede darse el caso en algún proyecto que ya tengamos todas las entidades de dominio creadas por cualquier motivo, pues en este caso nos viene perfecto el uso de Code First, ya que vamos a reutilizar las entidades de dominio que ya tenemos y podemos usarlas para crear nuestra base de datos, ahí encontramos una ventaja por ejemplo, y digamos que hablando un poco más orientado a los gustos de los desarrolladores, para las personas que no son amantes del código auto generado, de un diseñador y que prefieren codificar ellos mismos la totalidad de su código, es la mejor elección.

Bueno y ahora nos surge otra duda, ¿Cómo hace Entity Framework Code First para crear la base datos y mapearla con mis entidades de dominio?

Como ya vimos en artículos anteriores en EF se trabaja con un Contexto (Context), el cuál agrupa todos los objetos de nuestro modelo conceptual, bueno para code first es igual y es el primer objeto que debemos crear para generar nuestra base de datos, entonces en el constructor de nuestro contexto podemos pasar como parámetro el nombre que queremos darle a la DB una vez se cree, o también podemos pasar como parámetro la cadena de conexión para nuestra DB, o simplemente no enviamos parámetros en el constructor y siendo así code first auto generará el nombre usando el name space en cual se encuentra el contexto y el nombre de la clase del mismo, algo como eso:

NameSpace.ContextClassName

Y para crear tablas con sus respectivas primary y foreign key y demás objetos usa algunas convenciones, las cuales podemos encontrar en el siguiente enlace:

Code First Conventions

Adicional quiero compartirles esta imagen que resume el proceso de creación de la base de datos:

Y para terminar quiero compartirles un par de conceptos fundamentales a la hora de trabajar con Code first y que vamos a ver muy a menudo en nuestra serie de artículos de Code First:

DbContext: Será el objeto que agrupará todos los elementos de nuestro modelo conceptual y manejará el mapeo de cada uno ellos con su par en la base de datos, incorpora el patrón unidad de trabajo y el patrón repositorio, aquí les dejo la referencia de msdn: DbContext

DbSet: Comúnmente usado como tipo de propiedades al interior de una clase que hereda del tipo DbContext, este recibe un tipo genérico el cual representa una entidad de nuestro dominio, de esta forma habilita las operaciones CRUD para la entidad especificada. Aquí les dejo la referencia de msdn: DbSet

DataAnotations: Serie de atributos con los cuales se pueden decorar las entidades del dominio y sus propiedades, permiten especificar características como longitud, exclusiones e mapeo, primary y foreign key, etc. Aquí les dejo la referencia de msdn: Code First Data Annotations

DataBase Migrations: Permite actualizar nuestra base de datos cuando existan cambios en nuestras entidades de dominio. Aquí les dejo la referencia de msdn: DataBase Migrations

Bueno y eso es todo, espero esta introducción a Entity Framework Code First sea de gran utilidad para ustedes y despeje muchas dudas, en artículos posteriores veremos más en detalle la forma de trabajo e implementación.

Saludos y buena suerte!

[EntityFramework] Resumen DataBase First

Hola amigos, les comparto el resumen de todo lo que aprendimos en esta serie de artículos acerca de Entity Framework DataBase first, espero les sea de utilidad:

Enfoques en Entity Framework

• Conocimos los tres enfoques que tenemos en Entity Framework, DataBase first, Model first y code first, y tuvimos un punto de referencia para elegir uno de ellos.

Iniciando con DataBase first

• Aprendimos a crear nuestro modelo conceptual a partir de nuestra base de datos.

Míralo tan fácil como quieras! dividiendo en colores tu modelo conceptual

• Vimos una característica que nos facilita mucho el entendimiento de nuestro modelo conceptual como lo es la división en diferentes colores.

Divide y vencerás! dividiendo en varios modelos nuestro modelo conceptual

• Aprendimos a dividir nuestro modelo conceptual en varios sub modelos, con el fin de organizarlo mejor y facilitar su entendimiento y manejo.

Actualizando nuestro modelo cuando surgen cambios en la base de datos

• Hicimos un ejemplo de cómo actualizar nuestro modelo cuando surgen cambios en la base de datos.

No tienes por qué dejar tus procedimientos almacenados en el olvido, úsalos en EF

• Conocimos las formas de cómo trabajar con procedimientos almacenados en EntityFramework.

Trabajando con enumeraciones

• Observamos el soporte para manejo de enumeraciones que nos ofrece Entity Framework.

Usando datos Geoespaciales

• Y para terminar observamos el soporte para trabajar con datos geoespaciales que nos brinda Entity Framework.

Saludos y buena suerte!