🙈

Code First
DataAnnotations - ForeignKey Attribute in EF 7 & EF Core ([Link])

Guia de Proyecto hecho en clase

En este proyecto se va a crear una base de datos que cumpla con el siguiente modelo:

Se realizara con el patron de diseño MVC

Aprendera sobre:

1. Agregar los Modelos Correspondientes a una tabla.

2. Hacer la Clase contexto.

3. Agregar los paquetes nuget necesarios.

4. Configurar los campos de una Entidad para espeficicar su propiedades con Data annotations y
onModelCreating.

Code First 1
 5. Agregar una cadena de conexion MySql.

6. Hacer Migraciones y actualizaciones en la base de datos.

7. Hacer Scaffolding para agregar los controladores y las vistas de los modelos.

8. Agregar datos a la base de datos desde una clase.

Nos va a servir para poder ver como se comporta una relacion uno a muchos donde el propietario puede tener
muchas mascotas y la mascota solo puede tener un propietario, Ademas este ejemplo nos ayudara a ver como
podemos poner valores por defecto y a especificar valores desde C#

1) Agregar los Modelos

Para este proyecto se crearan 2 entidades:

Propietario con atributos ID, Nombres, Apellidos

Mascota con atributos ID,Nombre, Alergias, Peso, FechaAdopcion

Primero vamos a crear el modelo para propietario, asi que debera crear una nueva clase en la carpeta models que
tenga el nombre de Propietario. (Tambien puede dar Shift+Alt+C )

Code First 2
 Despues debera agregar un atributo por cada uno de los campos que quiera en la tabla propietario, en este caso
van a ser (PropietarioID, Nombre, Apellidos)
Se hace de la siguiente manera:

Una vez creado la entidad Propietario, procederemos a crear la entidad Mascota que tendra (ID,Nombre,
Alergias, Peso, FechaAdopcion → se crea despues)

Code First 3
 Tenga en cuenta que el atributo representa un campo en la BD y debe tener el tipo de dato que usted necesita.
EJ = Si usted necesita un nombre debe ser string, si necesita una fecha debe ser DateTime para que no
hayan errores cuando se manejen los datos de la BD

🥳 Ya se tienen las estructuras basica para las entidades, Felicitaciones a completado el primer
paso!!! (Se hara una estructura mas completa en los pasos siguientes)

2) Hacer la Clase contexto

Crear El Proyecto
Crear un proyecto en visual studio que sea del siguiente tipo:

Ponga el nombre que quiera (En este caso es ExposicionCodeFirst ) y el resto de opciones pueden quedar
como se muestra a continuacion:

Code First 4
 A continuacion seleccione la verson de .Net core que desea utilizar para el proyecto (En este caso se
trabajara con .NET 7.0)

ℹ Tenga en cuenta que si no tiene el SDK instalado el programa no se creara correctamente, si

el programa se crea correctamente ignore este comentario, si no debera instalar SDK o mirar
que en las variables de ambiente esta correctamente referenciado en PATH

Una vez crea el proyecto debe tener una estructura como esta:

Code First 5
Code First 6
 📚 Teoria
La clase de contexto en Entity Framework Code First es la clase que representa la conexión a la
base de datos y que nos permite interactuar con ella. Es la clase que nos permite realizar las
operaciones CRUD (Create, Read, Update, Delete) en nuestra base de datos y que se encarga de la
creación y actualización de la base de datos a partir de las clases que hemos definido.
La clase de contexto debe heredar de la clase DbContext de Entity Framework y debe contener un
DbSet para cada una de las clases que queremos que se mapeen a tablas en nuestra base de

datos.
¿Por qué heredar de DbContext?
La clase de contexto en Entity Framework Code First debe heredar de la clase DbContext porque
DbContext es la clase base de Entity Framework que proporciona el contexto de base de datos

principal para las operaciones CRUD.

La clase DbContext es la encargada de realizar la conexión a la base de datos, de definir y
administrar las transacciones, de generar y actualizar el esquema de la base de datos, y de
proporcionar un conjunto de métodos para realizar operaciones CRUD en la base de datos.
Al heredar de DbContext, nuestra clase de contexto tendrá acceso a todos estos métodos y
propiedades y podremos utilizarlos para interactuar con la base de datos.

¿Para qué sirve el DbSet?

DbSet es una propiedad que se utiliza para definir una tabla en la base de datos a partir de una
clase de entidad. En otras palabras, es la propiedad que nos permite mapear una clase de
entidad a una tabla en la base de datos.
Cada DbSet representa una tabla en la base de datos y nos proporciona un conjunto de métodos
para realizar operaciones CRUD sobre esa tabla. Por ejemplo, podemos utilizar métodos como
Add, Remove y Find para agregar, eliminar y buscar registros en la tabla correspondiente.
¿Por qué necesita el constructor un dato de tipo DbContextOptions?

La clase de contexto en Entity Framework Code First necesita un objeto DbContextOptions<TContext>

en el constructor para configurar las opciones de conexión a la base de datos.
DbContextOptions es una clase que representa las opciones de configuración de DbContext, y nos
permite especificar la cadena de conexión a la base de datos, el proveedor de base de datos
utilizado, y otras opciones de configuración.
Al proporcionar un objeto DbContextOptions en el constructor de nuestra clase de contexto,
estamos diciéndole a Entity Framework cómo configurar la conexión a la base de datos y qué
proveedor de base de datos utilizar.
¿Por qué se crea la clase contexto en una carpeta llamada Data?

En una aplicación de tipo MVC con Entity Framework, es una buena práctica separar las clases de
contexto y de entidades en diferentes carpetas para tener una mejor organización del código y facilitar
el mantenimiento.

Por lo general, la clase de contexto se coloca en una carpeta llamada "Data" o "Repositories".

La carpeta "Data" suele ser utilizada para colocar todas las clases que tienen que ver con la capa de
acceso a datos, incluyendo el contexto de la base de datos, los repositorios y cualquier otra clase que
se encargue de interactuar con la base de datos.
De esta manera, se logra una mejor separación de responsabilidades entre las diferentes capas de la
aplicación y se facilita el mantenimiento y la modificación del código en el futuro.

Code First 7
 ¿Por qué necesito descargar el paquete de EntityFramework Core para poder heredar
DbContext?
Para poder heredar de DbContext , necesitas el paquete de Entity Framework Core, ya que esta clase se
encuentra en el espacio de nombres [Link] . DbContext es una clase que se
encuentra en el núcleo de Entity Framework Core y proporciona una API para realizar operaciones
CRUD y definir el modelo de datos de la aplicación.

Una vez que entendamos un poco más acerca del contexto de la clase, podemos empezar a crear nuestra clase
de contexto para el ejemplo. Para ello, necesitamos crear una nueva carpeta llamada Data en nuestro proyecto.

No debe estar dentro de otra carpeta

En la carpeta data agregamos otra clase que se llame como nuestro proyecto + Context
Ejemplo:

si el proyecto se llama peluqueria seria → PeluqueriaContext

una vez creada la tabla procederemos a hacer que herede de DbContext y a pasarle a la clase padre el dato
options que creamos en el constructor de la clase Context, tambien se agregara un DbSet por cada tabla que
tengamos en la BD.
para esto debemos instalar el paquete de EntityFrameworkCore.

Code First 8
 Aqui tenemos dos opciones:

1. usar el Package Manager Console para instalar el paquete:

con el comando Install-Package [Link]

2. Usando Manage NuGet Packages for solution

Code First 9
 se debe seleccionar browse porque lo vamos a buscar y todavia no lo tenemos, hacemos click en el y
seleccionamos el project en la parte derecha, cuando los archivos esten chuleados procedemos a instalar.
si lo hacemos asi nos pedira aceptar unos terminos, los aceptamos y se instala.

Una vez instalado el paquete de entity framework core podemos completar la clase de context

🥳 ¡Felicidades! Ha completado la creación de la clase contexto y ha agregado el DbSet para cada

tabla (conjunto de entidades).

3) Agregar los paquetes necesarios.

Code First 10
 📚 Teoria

Para el Proyecto se necesitan los siguientes paquetes:

[Link] (Ya fue instalado y explicado)

[Link]:
Este paquete incluye herramientas de línea de comandos para trabajar con Entity Framework
Core, como la migración de bases de datos y la generación de código. Si tienes instalado
este paquete, puedes ejecutar comandos como dotnet ef migrations add
y dotnet ef database update
para migrar tu base de datos. También puedes usar el comando dotnet ef dbcontext scaffold
para generar automáticamente un modelo de datos a partir de tu base de datos existente.

[Link]:

Este paquete proporciona las herramientas de diseño necesarias para trabajar con Entity
Framework Core desde Visual Studio. Incluye plantillas de proyecto, asistentes de
configuración y otras herramientas que te permiten trabajar con Entity Framework Core de
manera más eficiente. Al instalar este paquete, puedes usar Visual Studio para crear y
administrar tu modelo de datos, y generar código de manera más fácil.

[Link]:

Este paquete proporciona herramientas de generación de código para proyectos de [Link]

Core. Incluye plantillas de código y asistentes que te permiten generar rápidamente código
para agregar características comunes a tu aplicación, como la autenticación y la
autorización. Al instalar este paquete, puedes usar Visual Studio para generar código para tu
proyecto de [Link] Core.

[Link]:
el paquete de "[Link]" permite a los desarrolladores de software
utilizar Entity Framework Core con bases de datos MySQL, lo que les permite escribir código
más eficiente y mantener una separación clara entre la lógica de negocio y la manipulación
de datos.

Realmente ya al haber instalado el paquete de [Link] sabemos como instalar los otros.
Debera instalar todos los demas para seguir con el ejercicio.
Cabe aclarar que el paquete de conexion con la base de datos dependera del proveedor que estemos usando.

🥳 ¡Felicidades! Ha Agregado correctamente los paquetes necesarios para el proyecto.

4) Configurar mas Especificamente los campos de las tablas

Code First 11
 📚 Teoria
Existe data annotations y el metodo OnModelCreating para configurar los atributos de las
entidades
Tanto los Data Annotations como el método OnModelCreating son herramientas útiles para
configurar los atributos de las entidades en Entity Framework. Ambos permiten personalizar
cómo se mapean las entidades a las tablas de la base de datos, definir relaciones entre
entidades y especificar restricciones de validación, entre otras cosas.
Los Data Annotations son atributos que se aplican directamente a las propiedades de las
entidades. Estos atributos especifican la configuración de la propiedad, como la longitud
máxima, si es requerida o no, si es clave primaria o no, etc. Aquí te muestro un ejemplo de cómo
se utilizan los Data Annotations:

public class Producto

{
[Key] //Especifica llave primaria
public int Id { get; set; }

[Required] // Especifica No Nulo

[MaxLength(100)] // Especifica varChar(100)
public string Nombre { get; set; }

[Range(0, 10000)] // Especifica el rango para la base de datos

public decimal Precio { get; set; }
}

Por otro lado, el método OnModelCreating

se utiliza para configurar las entidades de forma más compleja. En este método, se pueden
definir relaciones entre entidades, especificar nombres de tablas y columnas, configurar índices,
entre otras cosas. Aquí te muestro un ejemplo de cómo se utiliza el método OnModelCreating:

public class MiContexto : DbContext

{
public DbSet<Usuario> Usuarios { get; set; }
public DbSet<Producto> Productos { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)

{
[Link]<Usuario>() //selecciona la entidad usuario
.HasMany(u => [Link]) // especifica que usuario puede tener muchos productos
.WithOne(p => [Link]) // Pero que un producto solo pertenece a un usuario
.HasForeignKey(p => [Link]); // en esta relacion la llave foranea sera UsuarioID

[Link]<Producto>() //selecciona la entidad producto

.Property(p => [Link]) // se seleccion el campo nombre
.HasColumnName("NombreProducto") // se le da NombreProducto como nombre en la BD
.HasMaxLength(50) // maximo 50 caracteres [varchar(50)]
.IsRequired(); // No puede ser nulo

[Link]<Producto>()
.HasIndex(p => [Link]); //Crea un indice en la columna nombre
}
}

¿Para qué sirven los atributos de navegación?

Code First 12
 Los atributos de navegación son una forma de establecer relaciones entre las entidades en
Entity Framework Core. Cuando se utiliza el enfoque Code First, puedes definir estas relaciones
simplemente agregando propiedades de navegación a tus entidades y decorarlas con los
atributos de navegación adecuados. Los atributos de navegación te permiten especificar la
cardinalidad de la relación (uno-a-uno, uno-a-muchos o muchos-a-muchos), el nombre de la
propiedad de navegación en la entidad de destino y las claves primarias y externas que se
utilizan para establecer la relación.

Ejemplos
Los atributos de navegación son una forma de establecer relaciones entre las entidades en
Entity Framework Core. Cuando se utiliza el enfoque Code First, puedes definir estas
relaciones simplemente agregando propiedades de navegación a tus entidades y decorarlas
con los atributos de navegación adecuados. Los atributos de navegación te permiten
especificar la cardinalidad de la relación (uno-a-uno, uno-a-muchos o muchos-a-muchos), el
nombre de la propiedad de navegación en la entidad de destino y las claves primarias y
externas que se utilizan para establecer la relación.

Aquí hay algunos ejemplos de cómo se usan los atributos de navegación:

Uno a uno: Si tienes dos entidades que se relacionan de manera uno a uno, puedes usar
el atributo [ForeignKey] para establecer la clave externa en una de las entidades y el
atributo [InverseProperty] en la otra entidad para especificar la propiedad de navegación
correspondiente.

csharpCopy code
public class User
{
public int UserId { get; set; }
public string Name { get; set; }

[ForeignKey("Profile")]
public int ProfileId { get; set; }
public UserProfile Profile { get; set; }
}

public class UserProfile

{
public int UserProfileId { get; set; }
public string Bio { get; set; }

[InverseProperty("Profile")]
public User User { get; set; }
}

En este ejemplo, la entidad User y UserProfile tienen una relación uno a uno, donde cada
usuario tiene un solo perfil. El atributo [ForeignKey] se usa en la propiedad ProfileId en la
entidad User para especificar la clave externa que apunta a la propiedad UserProfileId en la
entidad UserProfile . El atributo [InverseProperty] se usa en la propiedad User en la entidad
UserProfile para especificar que la propiedad de navegación correspondiente es la propiedad
Profile en la entidad User .

Uno a muchos: Si tienes dos entidades que se relacionan de manera uno a muchos,
puedes usar el atributo [ForeignKey] en la entidad que tiene la clave externa y el atributo
[InverseProperty] en la entidad que tiene la propiedad de navegación correspondiente.

Code First 13
 csharpCopy code
public class Blog
{
public int BlogId { get; set; }
public string Title { get; set; }

public ICollection<Post> Posts { get; set; }

}

public class Post

{
public int PostId { get; set; }
public string Content { get; set; }

[ForeignKey("Blog")]
public int BlogId { get; set; }
[InverseProperty("Posts")]
public Blog Blog { get; set; }
}

En este ejemplo, la entidad Blog y Post tienen una relación uno a muchos, donde cada blog
tiene muchos posts. La propiedad Posts en la entidad Blog especifica la colección de posts
que están relacionados con el blog. El atributo [ForeignKey] se usa en la propiedad BlogId en
la entidad Post para especificar la clave externa que apunta a la propiedad BlogId en la
entidad Blog . El atributo [InverseProperty] se usa en la propiedad Blog en la entidad Post para
especificar que la propiedad de navegación correspondiente es la propiedad Posts en la
entidad Blog .

Muchos a Muchos:

public class Student

{
public int StudentId { get; set; }
public string Name { get; set; }

public ICollection<CourseStudent> CourseStudents { get; set; }

}

public class Course

{
public int CourseId { get; set; }
public string Title { get; set; }

public ICollection<CourseStudent> CourseStudents { get; set; }

}

public class CourseStudent

{
[Key, Column(Order = 0)]
public int CourseId { get; set; }

[Key, Column(Order = 1)]

public int StudentId { get; set; }

[ForeignKey("CourseId")]
public Course Course { get; set; }

[ForeignKey("StudentId")]
public Student Student { get; set; }
}

En este ejemplo, la entidad Student y Course tienen una relación muchos a muchos, donde
cada estudiante puede estar inscrito en muchos cursos y cada curso puede tener muchos

Code First 14
 estudiantes inscritos. La entidad de enlace CourseStudent representa la tabla de unión entre
las entidades Student y Course .

Las propiedades de navegación CourseStudents en las entidades Student y Course apuntan a la

entidad de enlace CourseStudent . El atributo [InverseProperty] se usa para especificar la
propiedad de navegación correspondiente en la otra entidad. El atributo [ForeignKey] se usa
en la entidad de enlace CourseStudent para especificar la clave externa que apunta a la entidad
correspondiente.
Para configurar las claves primarias compuestas en la entidad de enlace CourseStudent ,
utilizamos el atributo [Key] en las propiedades CourseId y StudentId y especificamos el orden
de las columnas usando el atributo Column(Order = X) .
Para especificar las claves externas en la entidad de enlace CourseStudent , usamos el atributo
en las propiedades Course y Student para indicar que se relacionan con las
[ForeignKey]

entidades correspondientes a través de las propiedades CourseId y StudentId ,

respectivamente.

Recursos utiles

Documentación oficial de Microsoft: La documentación oficial de Microsoft sobre Data

Annotations y OnModelCreating es un buen lugar para empezar. En la documentación,
encontrarás una lista completa de los Data Annotations disponibles y cómo se usan, así como
ejemplos de cómo usar el método OnModelCreating para configurar el modelo de datos. Puedes
encontrar la documentación en los siguientes enlaces:

Data Annotations en Entity Framework Core: [Link]

us/ef/core/modeling/index#data-annotations

Configuración de modelo de datos en Entity Framework Core:

[Link]

Entity Framework Core Attributes Library: Esta biblioteca es una colección de Data Annotations
personalizados que puedes utilizar en tus entidades para validar y configurar tus propiedades.
Puedes encontrar más información en el siguiente enlace: [Link]
elements/[Link]

Curso de Entity Framework Core de Pluralsight: Si prefieres aprender a través de cursos en

línea, te recomiendo este curso de Pluralsight. En él, aprenderás cómo usar Entity Framework
Core para construir aplicaciones de .NET Core, incluyendo cómo usar Data Annotations y el
método OnModelCreating para configurar tus entidades. Puedes encontrar más información en el
siguiente enlace: [Link]
started

Blog de Julie Lerman: Julie Lerman es una reconocida experta en Entity Framework, y su blog
es una excelente fuente de información y tutoriales sobre Entity Framework. En su blog,
encontrarás muchos artículos sobre Data Annotations y OnModelCreating , así como otros temas
relacionados con Entity Framework. Puedes encontrar su blog en el siguiente enlace:
[Link]

Para este ejemplo vamos a definir las variables de la siguiente manera:

Nombres o Apellidos → varChar(40)

Code First 15
 Alergias → varChar(60)

tipos decimales → decimal (5,2)

tipos fecha → DATE

Ademas se va agregar una relacion entre propietario y mascota, donde un propietario puede tener muchas
mascotas pero una mascota solo pertenece a un propietario.
Se debe agregar tambien a mascotas un atributo de navegacion de Tipo Propietario para establecer la relacion
muchos a uno.

public class Mascota

{
[Key]
public int MascotaID { get; set; }

[Required]
[MaxLength(40)]
public string MascotaNombre { get; set; }

[MaxLength(60)]
public string? Alergias { get; set; }

[Required,Column(TypeName = "Decimal(5,2)")]
public double peso { get; set; }

[Required,Column(TypeName ="Date")]
public DateTime fechaAdopcion { get; set; }

[ForeignKey("Propietario")]
public int PropietarioID { get;set; }
public Propietario? Propietario { get; set; }
}

En nuestra clase mascota entonces:

MascotaID quedo con el data annotation [Key] → especifica primary key

MascotaNombre quedo con [Required] → no nulo y [MaxLength(40)] → varchar(40)

alergias no es requerido porque mas adelante le vamos a poner un valor por defecto para cuando no se
ponga nada en este campo, Tiene [MaxLength(60)] → varchar(60)

peso tiene [Required] → no nulo y [Column(TypeName = "Decimal(5,2)")] → Que especifica el tipo de dato en la
BD como Decimal(5,2)

Se creo fechaAdopcion que se le pone [Column(TypeName = “Date”)] → especifica que en la BD va a ser

de tipo DATE

se creo el Id que relaciona propietario con mascota, esta va a ser una llave foranea, Ademas se agrego el
atributo de navegacion Propietario. (Tiene el tipo de dato Propietrario? en vez de Propietario Para que
C# entienda que este dato pueda ser nulo y no nos genere conflicto a la hora de crear Entidades
mascota desde las vistas)

Ahora se modifica la clase Propietario:

public class Propietario

{
[Key]
public int PropietarioId { get; set; }

[Required,MaxLength(40)]

Code First 16
 public string PropietarioNombre { get; set; }

[Required,MaxLength(40)]
public string PropietarioApellido { get; set; }
}

Nuestro cliente dice que la mayoria de los perros no tienen alergias y que le gustaria no tener que estar
escribiendo Ninguna todo el rato que ingrese una mascota, Entonces nosotros como desarrolladores le
daremos un valor por defecto = "Ninguna" al atributo alergias en la clase contexto con el metodo
OnModelCreating :

public class ExposicionCodeFirstContext:DbContext

{
public ExposicionCodeFirstContext(DbContextOptions<ExposicionCodeFirstContext> options)
:base (options) { }

public DbSet<Mascota>Mascota { get; set; }

public DbSet<Propietario>Propietario { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)

{
[Link](modelBuilder);
[Link]<Mascota>()
.Property(m => [Link])
.HasDefaultValue("Ninguna");
}
}

Si esta haciendo esto en SQL Server

public class ExposicionCodeFirstContext:DbContext

{
public ExposicionCodeFirstContext(DbContextOptions<ExposicionCodeFirstContext> options)
:base (options) { }

public DbSet<Mascota>Mascota { get; set; }

public DbSet<Propietario>Propietario { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)

{
[Link](modelBuilder);
[Link]<Mascota>()
.Property(m => [Link])
.HasDefaultValueSql("'Ninguna'");
}
}

OnModelCreating necesita un parametro en su constructor de tipo ModelBuilder al que por defecto se le llama
modelBuilder. Con este parametro se accede a una entidad del tipo especificado adrentro de <>, en este caso
accedemos a la Entidad Mascotas con [Link]<Mascota> ; una vez que accedemos a la entidad mascota
seleccionamos una propiedad y con las expresiones labmda creamos un objeto mascota para acceder al atributo
alergias → [Link]<Mascota>().Property( m => [Link]) ; Ahora que hemos accedido al atributo alergias
procedemos a darle las configuraciones adicionales que queramos tal como un valor por defecto →
[Link]<Mascota>().Property( m => [Link]).HasDefaultValue("Ninguna");

Code First 17
 🥳 ¡Felicidades! ¡Hemos aprendido los métodos para especificar configuraciones en los atributos y
hemos configurado de manera más concreta cada uno de los campos en las tablas que vamos a
utilizar! Además, hemos hecho una relación entre las tablas. ¡Excelente trabajo!

5) Agregar una cadena de conexion MySql.

Code First 18
 📚 Teoria

¿Qué es una cadena de conexión?

La cadena de conexión es una cadena de texto que especifica los detalles necesarios para
establecer una conexión con una base de datos. En el contexto de Entity Framework, la cadena de
conexión se utiliza para establecer una conexión con la base de datos subyacente que se utilizará
para almacenar y recuperar datos.
La cadena de conexión contiene información como la ubicación del servidor de base de datos, el
nombre de la base de datos, las credenciales de autenticación necesarias para acceder a la base de
datos, y otros detalles específicos de la base de datos, como el proveedor de base de datos y los
parámetros adicionales necesarios para establecer la conexión.

¿Con qué proveedores de bases de datos se puede hacer una conexión en Entity Framework?

Algunos de los proveedores de bases de datos compatibles con Entity Framework son:

1. Microsoft SQL Server

2. MySQL

3. Oracle

4. PostgreSQL

5. SQLite

Además, Entity Framework también admite otros proveedores de bases de datos a través de
proveedores de terceros, lo que significa que si necesitas conectarte a una base de datos que no
está en la lista anterior, es posible que aún puedas hacerlo utilizando un proveedor de terceros
compatible con Entity Framework.
¿Cómo se escribirían los connection string?

Para Microsoft SQL Server:

"ConnectionStrings": {
"MiConexionSQLServer": "Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;",
"MiConexionMySQL": "Server=myServerAddress;Database=myDataBase;Uid=myUsername;Pwd=myPassword;",
"MiConexionOracle": "Data Source=myOracleDB;User Id=myUsername;Password=myPassword;",
"MiConexionPostgreSQL": "Host=myServerAddress;Database=myDataBase;Username=myUsername;Password=myPassword;",
"MiConexionSQLite": "Data Source=[Link];"
}

se puede especificar el puerto con port=numeroDelPuerto

Estas cadenas de conexion son un ejemplo, si quiere usarlas para conectar con la base de datos
necesita remplazar lo que esta despues del = con la informacion que corresponda.

¿Cuáles son los paquetes que debo instalar correspondientes a cada proveedor de base de datos?

ParaSqlServer -> [Link]

Para MySql -> [Link]
Para Oracle -> [Link]
Para PostgreSQL -> [Link]
Para SqLite -> [Link]

¿Por qué se suele establecer la conexión desde la clase [Link]?

Code First 19
 La clase [Link] es el punto de entrada de una aplicación C# y es el lugar donde se suele
configurar y establecer la conexión a la base de datos en Entity Framework. La razón principal de
esto es que al establecer la conexión desde la clase [Link] , la conexión estará disponible en tod
la aplicación y no será necesario establecerla cada vez que se necesite realizar una operación en la
base de datos.

Además, al establecer la conexión en la clase [Link] , se pueden utilizar los mecanismos de

configuración de la aplicación para proporcionar la cadena de conexión de forma dinámica, lo que
permite cambiar la cadena de conexión en tiempo de ejecución sin tener que modificar el código
fuente.

Otra razón por la que se suele establecer la conexión en la clase [Link] es para tener un punto
centralizado de configuración de la base de datos en la aplicación. Esto facilita el mantenimiento y l
gestión de la conexión a la base de datos, ya que todas las operaciones relacionadas con la
conexión se realizan en un solo lugar.

¿Cómo puedo saber cuál es la versión de mi servidor MySQL?

Para obtener la versión del servidor MySQL, puedes ejecutar una consulta SQL en la base de datos.
A continuación se muestra un ejemplo de cómo hacerlo:

SELECT VERSION();

Una vez que conocemos mejor el funcionamiento de las cadenas de conexion realizaremos la cadena de
conexion para nuestro proyecto. Haremos lo siguiente:

1. poner el connection String para MySql.

Tendremos que dirigirnos al archivo JSON y poner lo siguiente:

"ConnectionStrings": {
"MySqlConexion": "Server=Localhost;Database=Exposicion;Uid=root;Pwd=admin;port=3307;"
}

Esto cambia dependiendo si el servidor es local o remoto, si es local se puede dejar localhost, en database se
puede poner un nombre cualquiera, el que se desee para la base de datos, Uid = el usuario con el que se va a
usar esa BD, pwd = la contraseña que tenga ese usuario y port = el numero de puerto de la conexion MySql,
si el puerto es 3306 no hace falta poner port=####;

2. En la clase program crear la conexion.

Una vez que tenemos el connection string nos dirigimos a la clase program para poner lo siguiente:

//Creamos una variable que contiene la version del servidor MySql

//La version depende de cada uno la que tenga
var serverVersion = new MySqlServerVersion(new Version(8,0,32));

[Link]<NombreClaseContexto>(options => {
[Link]([Link]("NombreDeLaCadenaDeConexion"),serverVersion);
});

Debera quedar de la siguiente manera:

Code First 20
 si no se coloca despues de la variable builder y antes de la variable app, la conexion falla.

🥳 Ahora que se tiene la conexion vamos a hacer una migracion y vamos a actualizar la base de
datos para que se creen las tablas.

6) Hacer Migraciones y actualizaciones en la base de datos.

Code First 21
 📚 Teoria
¿Por qué se hacen las migraciones? ¿Tienen ese nombre por alguna razón en particular?
Las migraciones en Entity Framework son una forma de mantener actualizada la estructura de la
base de datos a medida que evoluciona el modelo de la aplicación. En lugar de tener que crear
manualmente la base de datos y actualizarla cada vez que cambia el modelo, Entity Framework
genera las migraciones automáticamente a partir de los cambios que se hacen en el modelo y
aplica esas migraciones a la base de datos.

El número que aparece al principio del archivo de migración en Entity Framework se conoce
como "número de versión". Cada archivo de migración representa un conjunto de cambios
específicos que se aplican a la base de datos, y el número de versión se utiliza para identificar
de manera única cada conjunto de cambios.

Cuando se crea una nueva migración en Entity Framework, se genera automáticamente un

número de versión único para el conjunto de cambios. El número de versión se basa en el
tiempo actual, en formato de fecha y hora, y se convierte en un número entero que se utiliza
como identificador único para la migración.

Por ejemplo, supongamos que creamos una migración en Entity Framework el 1 de marzo de
2023 a las 10:30 a.m. El número de versión de la migración podría ser 20230301103000. Este
número de versión indica que la migración se creó el 1 de marzo de 2023 a las 10:30 a.m. y es
único para esa migración específica.
como se hace una migracion?
En la consola de comandos Add-Migration <NombreDeLaMigración>

y una vez que se haya creado la migración, puedes aplicarla a la base de datos ejecutando el
siguiente comando en la consola del Administrador de paquetes. Update-Database

Creamos la aplicacion en la consola de paquetes:

Code First 22
 Asi se vera al finalizar correctamente.

Cuando creamos la primera migracion automaticamente en el proyecto se crea la carpeta migrations que es
donde se guardaran todas las migraciones.

Ahora vamos a subir esa migracion a la BD con el comando Update-Database

El comando update-Database va a buscar la ultima migracion hecha y de ahi hara los cambios en la BD

Cuando se realice correctamente saldra done. al final:

Lo que nos queda seria verificar que se haya creado nuestra BD para esto, podemos verificar en cualquier
herramienta de administracion de base de datos.

📚 DBeaver y MySQL Workbench son dos herramientas de administración de bases de datos muy
populares y ampliamente utilizadas por los desarrolladores y administradores de bases de
datos.

Para el ejercicio miraremos en WorkBench y veremos que la BD fue creada:

Code First 23
 Se ha creado correctamente y podemos verificar cada tabla y sus campos, Se crea una tabla de migraciones
donde se guardan las migraciones hechas. (esto lo hace automaticamente Entity Framework)

Como vemos se creo todo correctamente.

📚 Felicitaciones! Ya creo la base de datos, ahora solo falta hacer el Scaffolding para crear los
controladores y las vistas y que asi pueda agregar datos en las tablas!!

7) Hacer Scaffolding, Agregar Controladores y Las vistas.

Code First 24
 📚 Teoria
Que es el Scaffolding?

es un proceso automatizado en el que se genera el código inicial para crear una aplicación web
basada en un modelo de datos. En otras palabras, el scaffolding es una herramienta que puede
generar automáticamente la estructura básica de una aplicación web, incluidas las páginas web,
modelos de datos, vistas y controladores.
En el contexto de [Link] MVC , el scaffolding permite generar el código de una aplicación web
MVC a partir de una base de datos existente. Por ejemplo, puede generar automáticamente los
modelos de datos, vistas y controladores necesarios para crear una aplicación web que
interactúe con una base de datos determinada.

Para que sirven los controladores?

estos son componentes en una aplicación web que se utilizan para procesar y controlar la lógica
de negocio. En una aplicación web MVC, los controladores actúan como intermediarios entre las
vistas y los modelos. El controlador recibe una solicitud del usuario a través de una vista,
procesa la solicitud y realiza la acción correspondiente, como obtener o actualizar datos en la
base de datos. Luego, el controlador devuelve una respuesta a la vista para que se muestre al
usuario.

Ahora que conocemos un poco sobre scaffolding y llevamos el proyecto en buena forma, podemos crear los
controladores y las vistas con scaffolding para por fin poder correr el programa y agregar datos desde la web.
En la carpeta controllers dar click derecho y agregar un item con scaffolding

Code First 25
 Seleccionamos la opcion que dice controlador con vistas usando Entity Framework

Code First 26
Code First 27
 En la clase modelo debe especificar la entidad a la cual le va a dar ese controlador y tambien se debe seleccionar
la clase contexto que en este caso es ExposicionCodeFirstContext.
El nombre del controlador puede dejarlo por defecto ya que asi esta bien escrito por convencion.

Una vez creado deberemos hacer los mismo con la entidad Mascota

Si todo salio bien tendremos la carpeta controladores y la carpeta vista de la siguiente manera:

Code First 28
 Ya por ultimo para que pueda probar el codigo debe acceder a Layout que esta en la carpeta Views → Shared →
[Link]

En el body, en la etiqueta <ul> agregaremos otras dos links para acceder a las vistas de propietarios y mascotas.

Code First 29
 Ponga lo siguiente abajo del ultimo <li>

<li class="nav-item">
<a class="nav-link text-dark" asp-area="" asp-controller="Propietarios" asp-action="Index">Propietarios</a>
</li>
<li class="nav-item">
<a class="nav-link text-dark" asp-area="" asp-controller="Mascotas" asp-action="Index">Mascotas</a>
</li>

cada etiqueta <a> tiene una propiedad asp-controller donde pondremos el controlador al que queremos llamar,
ademas la propiedad asp-action nos pide la accion que vamos a realizar con ese controlador.

📚 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
Felicidades! Puede Correr el programa e ingresar a los links para que agregue datos a gusto! ya
tiene la estructura principal para un proyecto code first con MVC y EntityFramework!
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨

8) Agregar datos desde una clase

Code First 30
 📚 Teoria
Por que tener una clase Seed Data para agregar datos desde la clase en vez del apartado web?
La clase Seed Data es una clase que se utiliza para agregar datos de prueba o iniciales a la base
de datos en la fase de desarrollo de una aplicación. En lugar de ingresar manualmente los datos
en la base de datos a través del apartado web, la clase Seed Data se utiliza para automatizar el
proceso de agregar datos a la base de datos de manera programática.

Hay varias ventajas en tener una clase Seed Data para agregar datos desde la clase en lugar del
apartado web:

1. Automatización: Al tener una clase Seed Data, se puede automatizar el proceso de agregar
datos de prueba o iniciales a la base de datos. Esto significa que los datos se pueden
agregar a la base de datos de manera programática, lo que ahorra tiempo y reduce la
posibilidad de errores al ingresar datos manualmente a través del apartado web.

2. Reproducibilidad: Al agregar datos a través de la clase Seed Data, se asegura la

reproducibilidad de los datos. Esto significa que los mismos datos se pueden agregar a la
base de datos cada vez que se inicie la aplicación, lo que facilita el desarrollo y las pruebas.

3. Flexibilidad: Al agregar datos a través de la clase Seed Data, se puede personalizar los datos
de prueba o iniciales según sea necesario. Esto significa que se pueden agregar diferentes
tipos de datos y configuraciones para probar diferentes escenarios y situaciones.

Porque se le pone el nombre de Seed Data y no otro nombre?

El término "Seed Data" (datos de semilla en español) se utiliza comúnmente en el desarrollo de
software para referirse a un conjunto inicial de datos que se utilizan para poblar una base de
datos o una aplicación al comienzo del desarrollo o durante las pruebas.
La palabra "seed" se refiere a la idea de plantar una semilla que luego crecerá y se desarrollará.
De manera similar, los datos de semilla se utilizan como una base inicial para desarrollar la
aplicación y permitir su crecimiento y desarrollo posterior.

Este paso es opcional pero le puede servir para sus proyectos.

Para hacer este paso y ver que funciona debera borrar todos los datos que haya creado en la base de datos.
Crearemos una clase en la carpeta Models que se llame SeedData

Code First 31
 en la clase agregaremos el siguiente codigo:

public static void Initialize(IServiceProvider serviceProvider)

{
using (var context = new ExposicionCodeFirstContext(
[Link]<DbContextOptions<ExposicionCodeFirstContext>>()))
{
if ([Link]())
{
return;
}
[Link](
new Propietario
{
PropietarioNombre = "Sebastian",
PropietarioApellido = "Galindo"
},
new Propietario
{
PropietarioNombre = "Miguel",
PropietarioApellido = "Moreno"
},
new Propietario
{
PropietarioNombre = "Julian",
PropietarioApellido = "Lara"
},
new Propietario
{
PropietarioNombre = "Jose",
PropietarioApellido = "Tuozzo"
}
);
[Link]();
}
}

Code First 32
 Basicamente se usa el metodo initialize, se crea una conexion a la base de datos con la clase contexto y primero
se verifica si hay propietarios, Si no hay propietarios en esa tabla se accedera con el contexto a la clase
propietario (Tabla) y se le agregara un rango de datos.

Despues de tener la clase SeedData preparada, vamos a la clase program para agregare el inicializador y que asi
se agreguen los datos.

Al final de escribir los datos que se quieren agregar se debe guardar los cambios asiendo uso de
[Link]();
Se pone el siguiente codigo despues de la variable app.

using(var scope = [Link]())

{
var services = [Link];
[Link](services);
}

Ahora puede probar la aplicacion y si elimino todos los datos anteriores, ahora deberia tener en propietario estos 4
datos que se agregaron por consola:

Code First 33
 📚 Teoria
Que es el metodo CreateScope()?

el método CreateScope() se utiliza para crear un nuevo ámbito de servicio (service scope) en el
cual se pueden registrar y resolver servicios específicos para una operación o transacción
particular.
Un ámbito de servicio es un objeto que se utiliza para encapsular una serie de servicios que se
necesitan para completar una operación específica. El ámbito de servicio se crea a partir de una
clase IServiceScopeFactory , que se registra en la colección de servicios de la aplicación.
Cuando se llama al método CreateScope() , se crea un nuevo ámbito de servicio que contiene una
copia del contenedor de servicios raíz de la aplicación. Dentro de este ámbito de servicio, se
pueden registrar servicios adicionales que se utilizarán durante la duración de la operación o
transacción.
Que es el metodo ServiceProvider?

se utiliza para obtener el contenedor de servicios dentro de un ámbito de servicio creado con el
método CreateScope() .

El contenedor de servicios es un objeto que contiene una colección de servicios que se pueden
resolver y utilizar en la aplicación. En Entity Framework, el contenedor de servicios se utiliza
para resolver servicios específicos, como el contexto de base de datos DbContext, que se
necesitan para realizar operaciones de base de datos.

🥳 Felicidades!! a terminado todos la guia de Code first En .Net Core, esperamos que haya sido util
para su estudio.

Code First 34