Introducción

Estamos en la etapa inicial de ParkingApp, una aplicación sencilla de estacionamiento de vehículos. En esta etapa vamos a crear nuestra capa de dominio (ParkingApp.Domain) donde vamos a definir las clases de negocio. Crearemos el contexto y vamos aplicar los comandos necesarios para crear nuestra primera migración en ef core 2.

Solución final

solution_parkingApp
Solución de ParkingApp

Nuestro modelo

La capa ParkingApp.Domain es una biblioteca de clases .net stantard en la que vamos a definir todas nuestras clases de negocio.

La clase Category.cs representa a las categorías de los vehículos que van a ingresar al estacionamiento. En el próximo articulo haremos las altas necesarias y en ellas definiremos las categorías disponibles del estacionamiento para cada vehículo. Como verán, definimos una propiedad de tipo List<T> ya que una categoría estará relacionada con muchos vehículos.

    [Table("Category")]
    public class Category
    {
        public int Id { get; set; }

        [Required, StringLength(50)]
        public string Name { get; set; }

        public List<Vehicle> Vehicles { get; set; }
    }

La clase Parking.cs representa a un estacionamiento para un vehículo en un momento especifico. Establecemos dos propiedades de tipo DateTime para especificar la fecha y horario de entrada y salida del vehículo en el estacionamiento. Una propiedad de tipo String para el ticket que se va a generar automáticamente en el sistema.

    [Table("Parking")]
    public class Parking
    {
        public int Id { get; set; }
        public int VehicleId { get; set; }

        [Required, StringLength(10)]
        public string Ticket { get; set; }

        public DateTime CheckIn { get; set; }
        public DateTime? CheckOut { get; set; }

        public Vehicle Vehicle { get; set; }
    }

Por ultimo, la clase Vehicle.cs representa a un vehículo que va a tener asociada una categoría y una lista de posibles estacionamientos durante sus visitas al establecimiento. Una propiedad de tipo String para la patente, la cual identifica al auto. 

    [Table("Vehicle")]
    public class Vehicle
    {
        public int Id { get; set; }
        public int CateogoryId { get; set; }

        [Required, StringLength(10)]
        public string LicensePlate { get; set; }

        public Category Category { get; set; }
        public List<Parking> Parkings { get; set; }
    }

Nuestra capa de acceso a datos

Agregar Entity Framework Core a través de nuget

Instalaremos el paquete Microsoft.EntityFrameworkCore.SqlServer y Microsoft.EntityFrameworkCore.Tools.

Estos paquetes serán los encargados de instalar todas las dependencias necesarias para compilar ef core 2 dentro de nuestra App.

PM> Install-Package Microsoft.EntityFrameworkCore.SqlServer
PM> Install-Package Microsoft.EntityFrameworkCore.Tools

Creando nuestro contexto

La clase ParkingContext.cs representa al contexto de nuestra aplicación. Debemos heredar de la clase DbContext para utilizar ef core 2. Esta clase nos proporciona la API para comunicarnos con la base de datos para establecer la conexión, ejecutar consultas, realizar el mapeo con las clases de dominio y manejo de transacciones.

    public class ParkingContext : DbContext
    {
        public DbSet<Category> Categories { get; set; }
        public DbSet<Vehicle> Vehicles { get; set; }
        public DbSet<Parking> Parkings { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Category>()
                        .HasMany(p => p.Vehicles)
                        .WithOne(p => p.Category)
                        .HasForeignKey(p => p.CateogoryId);

            modelBuilder.Entity<Vehicle>()
                        .HasMany(p => p.Parkings)
                        .WithOne(p => p.Vehicle)
                        .HasForeignKey(p => p.VehicleId);
        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder
                .UseSqlServer(@"");
        }
    }

DbSet<T> 

La clase DbSet<T> representa una colección para una entidad. Permite consultar y ejecutar operaciones de alta, modificación y baja para una entidad.

Las consultas van desde obtener un objeto, múltiples objetos, filtros y ordenamiento, agrupamiento y objetos relacionados. Estas consultas son posibles gracias al poder que tiene LINQ.

Para las operaciones incluye:

  • Alta de una entidad y múltiples entidades (AddRange)
  • Modificar una entidad a partir del trackeo de la misma (EntityState.Modified)
  • Eliminar una entidad (Remove)

OnModelCreating(ModelBuilder modelBuilder)

Utilizaremos este método para establecer las relaciones entre nuestras entidades de negocio. Lo haremos a través de Fluent API. Este método es llamado por el framework cuando nuestro contexto es creado por primera vez.

OnConfiguring(DbContextOptionsBuilder optionsBuilder)

En este método establecemos nuestra configuracion para DbContext. Una de esas configuraciones es establecer que proveedor y que cadena de conexión para ese proveedor vamos a utilizar. 

En nuestro ejemplo, establecimos que vamos a utilizar SQL Server a través el método de extensión UseSqlServer en el cual le pasamos nuestra cadena de conexión como parámetro.

Aplicando nuestra primer migración

Para aplicar nuestra primera migración es necesario establecer punto de entrada para nuestra aplicación, para eso, hemos creado un proyecto de consola ParkingApp.UI. A este proyecto debemos instalarle el paquete Install-Package Microsoft.EntityFrameworkCore.Design y establecerlo como proyecto de inicio.

PM> Install-Package Microsoft.EntityFrameworkCore.Design

Y ahora ejecutamos la siguiente instrucción para crear nuestra primera migración llamada initial apuntando al proyecto ParkingApp.Data en la consola nuget.

PM> Add-Migration initial

La migración inicial va a contener dos métodos que van a representar lo que se va a generar nuevo y lo que se va a eliminar en la base de datos a nivel estructura.

Estos métodos son Up(MigrationBuilder migrationBuilder) y Down(MigrationBuilder migrationBuilder)

Esta es la estructura de nuestra migración

    public partial class initial : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "Category",
                columns: table => new
                {
                    Id = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    Name = table.Column<string>(maxLength: 50, nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Category", x => x.Id);
                });

            migrationBuilder.CreateIndex(
                name: "IX_Vehicle_CateogoryId",
                table: "Vehicle",
                column: "CateogoryId");
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "Parking");

            migrationBuilder.DropTable(
                name: "Vehicle");

            migrationBuilder.DropTable(
                name: "Category");
        }
    }

 **acorte la clase por lo visual, para ver completa la migración acceder a migracion github

Y por ultimo, debemos ejecutar el siguiente comando en la consola nuget

PM> Update-Database

 Y de esta forma creamos nuestra base de datos en ef core 2.

GITHUB /mpetrinidev

/blog-parking-ef-core-2

Branch [model-db]

¡Si te gusto el articulo, compártelo con tus contactos en las redes sociales!

Escribe una respuesta a este comentario

avatar
500
  Subscribe  
Notificar de