domingo, 13 de abril de 2014

Utilizando Sql Azure y Entity Framework

Hola amigos, en esta ocasión vamos ver cómo usar Entity Framework con una base de datos en la nube, más específicamente Sql Azure, vamos a ver cómo interactúan estas dos tecnologías, para esto vamos a crear nuestra base de datos Sql Azure, y luego vamos a crear nuestro modelo en Entity Framework usando el enfoque Data Base First y por último vamos a crear un sitio web con Asp.Net MVC para ver cómo funciona.

Antes de iniciar me parece oportuno hablar un poco acerca de Sql Azure:

Sql Azure: Base de datos relacional hospedada en la nube, basada en sql server, permite alta escalabilidad y automatización, garantiza alta disponibilidad, mantenimiento y actualización garantizado y ejecutado por Microsoft.

Ahora iniciemos creando nuestra base de datos en Sql Azure, para esto ingresamos a nuestro administrador de Microsoft Azure y elegimos la opción "Base de datos Sql":


Posteriormente hacemos clic en la opción "Nuevo" señalada en la imagen anterior, con la cual se nos mostrará la siguiente pantalla:


Allí elegimos la opción de creación rápida, en la cual solo debemos especificar el nombre de la base de datos y el servidor en el cual se creará o si deseamos podemos crear un nuevo servidor, para nuestro ejemplo llamaremos la base de datos "DemoEfSqlAzure" y elegiremos la opción de crear nuevo servidor, para lo cual debemos seleccionar una región de ubicación del servidor, un nombre de inicio de sesión y una contraseña y para terminar la creación hacemos clic en el botón "Crear base de datos Sql".

Ahora que tenemos nuestra base de datos creada la vamos a seleccionar y elegir la opción "Administrar", de inmediato se nos muestra en siguiente mensaje:


Es importante elegir la opción "Si" para que se agregue la excepción en el Firewall de este modo podamos acceder a nuestra base de datos de manera remota. Posteriormente se abre la consola de administración de la base de datos en la cual podemos agregar, modificar, eliminar tablas, modificar su estructura y demás operaciones en la base de datos.

Posteriormente vamos a crear una nueva tabla en nuestra BD llamada estudiantes:


Ahora que tenemos nuestra base de datos el siguiente paso es crear nuestro modelo en Entity Framework basado en ella, y para esto vamos a abrir nuestro excelente IDE Visual Studio y vamos a crear un nuevo proyecto de tipo librería:


y una vez creado el proyecto hacemos clic derecho sobre él y elegimos la opción agregar nuevo ítem, filtramos por ítems tipo datos y elegimos Ado.Net Entity Data Model y elegimos la opción agregar, y ahora se inicia el asistente para la creación de nuestro modelo conceptual, en el cual elegiremos el enfoque "Ef designer from DataBase" del cual hemos hablado en artículos anteriores.


Ahora debemos suministrar los datos de conexión a nuestra base de datos en la nube, más específicamente los siguientes:


El nombre del servidor lo podemos tomar de nuestro sitio de administración de Sql Azure, seleccionando nuestra base de datos y observando la sección de conexión a la base de datos, tal y cómo se muestra en la siguiente imagen:


Posteriormente probamos que nuestra conexión esté funcionando correctamente, seleccionamos la versión de Entity Framework con la que vamos a trabajar, en nuestro caso la 6.0, y por ultimo seleccionamos los objetos de la base de datos que queremos mapear:


Perfecto, ahora tenemos listo nuestro modelo conceptual en Entity Framework mapeado a nuestra base de datos en la nube, ahora para terminar nuestro ejemplo vamos a crear en la misma solución de Visual Studio un nuevo proyecto web Asp.Net MVC desde el cual vamos a consumir nuestro modelo conceptual de EF para probar su funcionalidad.

En primera instancia en nuestro proyecto de MVC vamos a referenciar nuestra librería creada anteriormente para lograr ver nuestro contexto, luego compilamos la solución y además vamos a copiar en el web.config la cadena de conexión que tenemos en el app.config de dicha librería, esto para lograr conectarnos a la base de datos desde nuestra aplicación web.

Y para terminar vamos a hacer clic derecho sobre la carpeta Controllers de nuestra aplicación web y vamos a elegir la opción "agregar controlador", y vamos a elegir la plantilla "MVC 5 Controller with views, using Entity Framework" lo que nos generará todas nuestras vistas y nuestro controller con las acciones Crud básicas las cuales usan el contexto para acceder a nuestra base de datos en la nube:



Si esperamos unos segundos veremos que Visual Studio nos genera nuestras vistas y nuestro controlador, en el cual sus acciones básicas usan el contexto de Entity Framework para interactuar con la base de datos. Nuestra acción para obtener todos los estudiantes por ejemplo:


Y si ejecutamos nuestra aplicación por fin veremos que interactuamos correctamente con nuestra base de datos Sql Azure a través de Entity Framework  y que podemos hacer operaciones básicas con nuestra tabla estudiantes a través de nuestra aplicación Asp.Net MVC.


Bueno amigos eso es todo de este ejemplo de cómo conectarnos a una base de datos Sql Azure desde Entity Framework, espero les sea de utilidad y de interés.

Saludos, y buena suerte!

martes, 8 de abril de 2014

[EntityFramework] Nueva funcionalidad Code First, Update Visual Studio 2013 2 RC

Hola amigos, como todos sabemos recientemente se presentó el Microsoft Build 2014, en el cual entre otras cosas se presentaron grandes avances en las diversas tecnologías Microsoft, cómo por ejemplo Windows 8.1, Windows Phone 8.1, Microsoft Azure, Visual Studio, etc. Y entre las actualizaciones para Visual Studio 2013 encontramos algo bastante interesante en cuento a Entity Framework se refiere, y es el hecho de poder trabajar con el enfoque Code First teniendo en primera instancia nuestra base de datos, y lo mejor de esto, sin tener que usar los power tools que solemos usar para lograr esto, entonces a través de esta nueva funcionalidad de VS podemos crear en primera instancia nuestra base de datos y posteriormente podemos generar nuestro modelo Code First a partir de ella, bastante bueno para los que preferimos este enfoque de EF, ya que ahora podemos crear y modelar nuestra BD como estamos acostumbrados y luego vamos a tener todo el dominio de nuestro modelo conceptual como preferimos, y todo esto soportado nativamente por  nuestro invaluable IDE Visual Studio.

Pero bueno veamos en acción esta nueva actualización, y lo primero que les recomiendo es descargar el Update Visual Studio 2013 2 RC y una vez lo tengan instalado podrán observar esta nueva opción de la que estamos hablando.

Ahora para iniciar vamos a crear un nuevo proyecto de tipo librería de clases, como se muestra a continuación:


Una vez creada nuestra librería de clases, vamos a hacer clic derecho sobre ella y vamos a elegir la opción "Agregar nuevo ítem", y vamos a elegir el tipo de ítem "ADO.NET Entity Data Model":


Ahora viene la novedad, veremos que tenemos habilitada la nueva opción "Code First From Data Base" la cual seleccionaremos para ver que viene a continuación:


Lo que viene a continuación es similar a lo que estamos acostumbrados cuando usamos el enfoque Data Base First, es decir generar una conexión a la base de datos y seleccionar los elementos de esta a mapear:



Todo muy sencillo como es de costumbre. Y por último si finalizamos el asistente y esperamos algunos segundos veremos que se generaran todas nuestras clases POCO y obviamente nuestro contexto usando Code First y usando una combinación de Data Anottations y Fluent Api para configurar nuestras entidades.

Bueno amigos eso es todo de este acercamiento a esta actualización recientemente liberada para Entity Framewor Code First, espero les sea de utilidad y de interés.

Saludos, y buena suerte!

domingo, 30 de marzo de 2014

Presentación Sql Azure y Entity Framework

Hola amigos, les comparto la presentación de mi charla dictada en el Global Windows Azure BootCamp Medellín en la cual estuve compartiendo sobre Sql Azure y Entity Framework, espero sea de su interés.


[EntityFramework] Resumen Code First

Hola amigos, les comparto el resumen de todo lo que aprendimos en esta serie de artículos acerca de Entity Framework Code 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.

  • Aprendimos conceptos básicos y a tener en cuenta sobre Entity Framework Code First.

  • Aprendimos a crear nuestro modelo conceptual a través de clases POCO y luego vimos cómo crear nuestra base de datos basados en nuestras clases.

  • Aprendimos a configurar nuestras entidades para definir ciertas características de base de datos a través de atributos o Data Anottations.

  • Aprendimos a configurar nuestras entidades para definir ciertas características de base de datos a través de Fluent Api.

  • Aprendimos a configurar una relación de uno a uno entre nuestras entidades.

  • Aprendimos a configurar una relación de uno a muchos entre nuestras entidades.

  • Aprendimos a configurar una relación de muchos a muchos entre nuestras entidades.
  • Aprendimos a usar migraciones para actualizar los cambios de nuestro modelo a nuestra base de datos, además aprendimos a inicializar nuestra base de datos con datos de configuración.
  • Aprendimos a usar la herramienta de Power Tools para Entity Framework en Visual Studio, en especial para Code First.
Saludos y buena suerte!

viernes, 28 de marzo de 2014

[EntityFramework] Power Tools

Hola amigos, para terminar con esta serie de post acerca de Entity Framework Code First les quiero compartir una herramienta llamada Entity Framework Power Tools, que no es más que una extensión para visual estudio, la cual pueden encontrar en el siguiente sitio:

Entity Framework Power Tools

O también la pueden descargar a través del administrador de extensiones de su Visual Studio. Esta es una extensión bastante útil a la hora de elegir trabajar con Code first. Por ejemplo puede ser bastante engorroso crear por primera vez nuestra base de datos basado en nuestras entidades, ya que nos podemos equivocar en muchas cosas y se nos pueden pasar muchos detalles, pues bueno a través de este power tool podemos ver cómo va a quedar nuestro modelo antes de generar la base de datos para validarlo.

Adicional otra característica que en mi opinión es bastante útil es la herramienta de ingeniería inversa, que nos permite generar las clases POCO para una base de datos ya existente, esto para las personas que prefieran solo trabajar con Code First y no con otro enfoque de Entity Framework, en caso tal que tengan ya creada su base de datos podrán generar las entidades a partir de esta.

Adicional esta herramienta tiene otras características, las cuales pueden observar en el link que mencioné anteriormente, en mi opinión las dos características mencionadas son las más útiles.

Bueno amigos eso es todo, espero les sea de utilidad esta herramienta en sus proyectos, con esto damos por terminado nuestro tutotial acerca Entity Framework code First.

Saludos y buena suerte!

martes, 18 de marzo de 2014

[EntityFramework] Usando migraciones para actualizar cambios en nuestro modelo en Code First

En esta serie de artículos sobre Entity Framework Code First hemos visto diversos temas, desde creación y configuración inicial, hasta trabajo con las entidades. Y ahora que vamos en este punto surge la necesidad y la interrogante, de cómo podemos actualizar nuestra base de datos cuando surgen cambios en nuestras entidades. Pues bueno en este post vamos a ver cómo lo podemos hacer.

En primera instancia quiero mencionar que hay varios tipos de inicialización de base de datos en Entity Framework Code First, los cuales explico a continuación:

CreateDatabaseIfNotExists: Es el tipo de inicialización establecido por defecto, y solo crea la base de datos si esta no existe, es decir la primer vez que ejecutemos la inicialización a no ser que eliminemos la base de datos y volvamos a ejecutar, hay que tener en cuenta que si trabajamos con esta inicialización y cambiamos nuestro modelo obtendremos un error.

DropCreateDatabaseIfModelChanges:  Este tipo de inicialización elimina la base de datos existente y la crea de nuevo con las actualizaciones, siempre y cuando existan cambios en nuestro modelo de clases, la desventaja con esto es que tendremos perdida de datos.

DropCreateDatabaseAlways: Este tipo de inicialización elimina la base de datos existente y la crea de nuevo sin importar si hay nuevos cambios en el modelo o no. esto siempre conllevara perdida de datos y problemas de rendimiento al siempre tener que crear la base de datos.

Custom DB Initializer: Adicional podemos crear nuestro propio inicializador de base de datos si necesitamos algo muy específico, otro tipo de configuraciones, o ejecutar otro proceso externo para la inicialización, para esto podemos crear una clase que herede de una clase de inicialización cómo por ejemplo MigrateDatabaseToLatestVersion u otro de los mencionados.

MigrateDatabaseToLatestVersion: Nos permite actualizar automáticamente la base de datos, una vez inicie la aplicación, las actualizaciones pendientes se reflejaran en nuestra base de datos, este tipo de inicialización nos permite conservar los datos obviamente si no se trata de una instrucción Drop o Delete por ejemplo. Con este tipo es que podremos implementar migraciones en nuestra aplicación, por esto es importante conocer los diferentes tipos de inicialización que nos ofrece Entity Framework Code Fist.

Ahora sí, vamos a ver cómo implementar migraciones en nuestra base de datos.

Lo primero que debemos hacer es habilitar las migraciones, esto lo podemos hacer a través de la consola de paquetes nuget, de la siguiente forma:

En la barra de menús de Visual Studio seleccionamos Herramientas / Administrador de paquetes / Consola de administrador de paquetes y en esta consola seleccionamos en proyecto por defecto nuestro proyecto de acceso a datos donde tenemos nuestro modelo y escribimos lo siguiente:

enable-migrations -EnableAutomaticMigrations:$true

De esta forma se habilitan las migraciones en nuestro proyecto nos damos cuenta si leemos todo el log que se genera en la consola, ahora vamos a configurar nuestro contexto para sopórtalas.

Ahora si vamos al explorador de soluciones, veremos que se ha creado una carpeta llamada Migrations la cual contiene una clase llamada Configuration.cs.

Si exploramos la clase Configuration veremos que en su constructor el atributo AutomaticMigrationsEnabled se encuentra establecido en true, tal cual se lo indicamos en la consola de Nuget al ejecutar el comando, adicional veremos que hay un método sobre escrito llamado Seed, el cual nos permite cargar datos iniciales en nuestra base de datos, por ejemplo para cargar datos de configuración que se requieran desde el inicio para su correcto funcionamiento o para cargar tablas maestras de nuestra base de datos.

    internal sealed class Configuration : DbMigrationsConfiguration<EF6CodeFirst.Dominio.Context>
    {
        public Configuration()
        {
            AutomaticMigrationsEnabled = true;
            AutomaticMigrationDataLossAllowed = true;
        }
 
        protected override void Seed(EF6CodeFirst.Dominio.Context context)
        {
            context.Productos.AddOrUpdate(
                p => p.Codigo,
                new Producto { Codigo = 1, Nombre = "Leche1", Descripcion = "Producto Lacteo" },
                 new Producto { Codigo = 2, Nombre = "Queso1", Descripcion = "Producto Lacteo" }
            );
        }
    }

Cómo vemos en el método Seed, creamos dos producto los cuales necesitamos crear al inicio para nuestro proyecto, adicional podemos ver que el constructor de la clase agregar el atributo AutomaticMigrationDataLossAllowed y lo establecimos en true, esto para asegurarnos que no suceda un error cuando posiblemente se pueda perder información tras una actualización, por ejemplo si decidimos eliminar un campo de alguna tabla tras la actualización nos diría que no se puede actualizar ya que se perdería la información que hay en ese campo, para esto habilitamos este atributo.

Para terminar con la configuración de las migraciones debemos indicar en el constructor de nuestro contexto que la estrategia de inicialización que vamos a usar es MigrateDatabaseToLatestVersion la cual explique anteriormente, y lo hacemos de la siguiente forma:

    public class Context : DbContext
    {
        public Context() : base("Productos")
        {
            Database.SetInitializer(new MigrateDatabaseToLatestVersion<ContextConfiguration>());            
        }
 
        public DbSet<Producto> Productos { getset; }
 
        public DbSet<Categoria> Categorias { getset; }
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            // Aquí haremos nuestras configuraciones con Fluent API.
 
            modelBuilder.Configurations.Add(new ProductoMappings());
 
            modelBuilder.Entity<Producto>().HasMany<Categoria>(c => c.Categorias).WithMany(e => e.Productos).Map(e =>
                e.MapLeftKey("IdProducto"));
 
            modelBuilder.Entity<Producto>().HasMany<Categoria>(c => c.Categorias).WithMany(e => e.Productos).Map(e =>
                e.MapRightKey("IdCategoria"));
 
            modelBuilder.Entity<Producto>().HasMany<Categoria>(c => c.Categorias).WithMany(e => e.Productos).Map(e =>
                e.ToTable("ProductosCategorias"));
 
            base.OnModelCreating(modelBuilder);
        }
    }

Ahora podemos crear una app de consola para probar nuestro código y nos daremos cuenta que se creará la base de datos según nuestras configuraciones incluyendo los datos de carga inicial que establecimos en el método Seed, y por ultimo para probar las migraciones podemos eliminar una propiedad de alguna entidad de dominio y veremos que los cambios se ven reflejados en nuestra base de datos.

Y bueno amigos, eso es todo, espero les sea de utilidad y de interés este post acerca de migraciones en Entity Framework code First.

Saludos y buena suerte!

miércoles, 5 de marzo de 2014

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

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

Relación de muchos a muchos mediante Data Annotations:

Para lograr configurar una relación de muchos a muchos en Entity Framework Code First solo debemos agregar una propiedad de tipo colección en cada una de las entidades, obviamente dónde una referencia a la otra, entonces veamos cómo quedarán nuestras entidades Producto y Categoría:

    [Table("Productos")]
    public class Producto
    {
        public Producto()
        {
            Categorias = new HashSet<Categoria>();
        }
 
        [Key]
        public int Codigo { getset; }
 
        [Required]
        [Column("Nombre", TypeName = "varchar", Order = 2)]
        public string Nombre { getset; }
 
        [MaxLength(100), MinLength(10)]
        public string Descripcion { getset; }
 
        [NotMapped]
        public string CodigoIso { getset; }
 
        public virtual ICollection<Categoria> Categorias { getset; }
    }

Cómo podemos ver agregamos la propiedad virtual de tipo ICollection Categoría, y en el constructor inicializamos dicha propiedad para evitar Null Reference Exception cuando agreguemos categorías al producto. Ahora hacemos lo mismo para la entidad Categoría:

    public class Categoria
    {
        public Categoria()
        {
            Productos = new HashSet<Producto>();
        }
 
        [Key]
        public int Id { getset; }
 
        [MaxLength(100)]
        public string Nombre { getset; }
 
        [MaxLength(200)]
        public string Descripcion { getset; }
 
        [Required]
        public virtual ICollection<Producto> Productos { getset; }
    }

Y listo ya con esto tenemos configurada nuestra relación de muchos a muchos entre las entidades Producto y Categoría, para probar vamos a crear una aplicación de consola y copiamos el siguiente código, obviamente con todo el contexto y demás que hemos creado en anteriores ejemplos:

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

Y ahora podemos ver que se han creado las tablas Productos y Categorías, y adicional se creó la tabla ProductoCategorias para representar la relación de muchos a muchos:


Relación de muchos a muchos mediante Fluent Api:

Ahora vamos a configurar la relación de muchos 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 { getset; }
 
        public DbSet<Categoria> Categorias { getset; }
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            // Aquí haremos nuestras configuraciones con Fluent API.
 
            modelBuilder.Configurations.Add(new ProductoMappings());
 
            modelBuilder.Entity<Producto>().HasMany<Categoria>(c => c.Categorias).WithMany(e => e.Productos).Map(e =>
                e.MapLeftKey("IdProducto"));
 
            modelBuilder.Entity<Producto>().HasMany<Categoria>(c => c.Categorias).WithMany(e => e.Productos).Map(e =>
                e.MapRightKey("IdCategoria"));
 
            modelBuilder.Entity<Producto>().HasMany<Categoria>(c => c.Categorias).WithMany(e => e.Productos).Map(e =>
                e.ToTable("ProductosCategorias"));
 
            base.OnModelCreating(modelBuilder);
        }
    }

Por ultimo si borramos la base de datos anteriormente creada y volvemos a ejecutar el proyecto de consola, veremos que obtendremos los mismos resultados.

Y bueno amigos, eso es todo, espero les sea de utilidad y de interés este post acerca de relación de muchos a muchos en Entity Framework code First, en próximos artículos observaremos más acerca de inicializaciones y migraciones en Code First.

Saludos y buena suerte!