EF Core:cómo crear una base de datos y una tabla

EF Core:cómo crear una base de datos y una tabla

En este artículo, mostraré cómo usar EF Core para crear una base de datos con una tabla. Al final, mostraré una aplicación de consola independiente que inserta un registro en esta base de datos.

Nota:Usaré SQL Server. No he probado esto con otros proveedores de bases de datos. Deje un comentario si está utilizando un proveedor de base de datos diferente y hágame saber cómo le fue.

Agregue los paquetes y herramientas de EF Core nuget

Instalar los paquetes nuget de EF Core

El primer paso es instalar los paquetes nuget de EF Core.

Ejecutando lo siguiente en la Consola del administrador de paquetes (Ver> Otras ventanas> Consola del administrador de paquetes).

Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Design
Code language: PowerShell (powershell)

Nota:si no utiliza SQL Server, deberá obtener el paquete nuget adecuado para su proveedor de base de datos.

Esto agregará las referencias del paquete a su archivo csproj, así:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <RootNamespace>ef_core_cli</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.4">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.4" />
  </ItemGroup>

</Project>

Code language: HTML, XML (xml)

Instalar la herramienta dotnet ef

La herramienta dotnet ef se utiliza para instalar y actualizar la base de datos.

Instale la herramienta ejecutando lo siguiente en la línea de comando:

dotnet tool install --global dotnet-ef
Code language: PowerShell (powershell)

Añadir un modelo

Un modelo es una clase que representa una tabla en la base de datos. Cada propiedad es una columna en la tabla. Puede usar atributos de anotación de datos para definir cómo debe crearse cada columna.

Cuando use EF Core para crear la base de datos, usará las clases modelo para crear las tablas.

Aquí está la Película clase modelo. Esto se usará para crear las Películas mesa.

using System.ComponentModel.DataAnnotations;

public class Movie
{
	[Key]
	public int Id { get; set; }

	[Required]
	[MaxLength(500)]
	public string Name { get; set; }

	[Required]
	public int ReleaseYear { get; set; }

	[Required]
	[MaxLength(500)]
	public string Description { get; set; }

	[Required]
	public int RuntimeMinutes { get; set; }
}
Code language: C# (cs)

Anotaciones de datos

La Película El modelo utiliza atributos de anotación de datos para especificar cómo se debe crear la tabla. Hay más anotaciones de datos disponibles, pero solo explicaré las tres que se están usando en la Película modelo:

Anotación	¿Qué significa?	Ejemplo
Clave	La columna es la clave principal.	[Clave] public int Id { get; establecer; } Genera columna: Id (PK, int, not null)
Obligatorio	La columna no acepta valores NULL.	[Obligatorio] public int ReleaseYear { get; establecer; } Genera columna: ReleaseYear (int, no null)
Longitud máxima	El tamaño del campo de la columna. Si no especifica esto, los campos de cadena tendrán el tamaño de campo MAX.	[Obligatorio] [MaxLength(500)] public string Nombre { get; establecer; } Genera columna: Nombre (nvarchar(500), no nulo)

Agregue su propia clase DbContext

Al crear la base de datos, EF Core utilizará la información de su clase DbContext para determinar cómo crear la base de datos.

Entonces subclase DbContext y:

Sobrescriba OnConfiguring y pase una cadena de conexión.
Agregue una propiedad DbSet para cada modelo.

using Microsoft.EntityFrameworkCore;

public class StreamingServiceContext : DbContext
{

	private readonly string ConnectionString;
	public StreamingServiceContext(string connectionString)
	{
		ConnectionString = connectionString;
	}
	protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
	{
		optionsBuilder.UseSqlServer(ConnectionString);
	}

	public DbSet<Movie> Movies { get; set; }
}
Code language: C# (cs)

Opcional:agregue su ConnectionString a un archivo de configuración

Necesita tener su cadena de conexión en algún lugar . Voy a mostrar cómo agregarlo a appsettings.json y luego anularlo usando los secretos de usuario. Este paso es opcional, porque puede optar por tratar la cadena de conexión de manera diferente.

Agregar appsettings.json

Agregue un nuevo archivo llamado appsettings.json.
Ajústelo a Copiar si es más nuevo .
Ponga la sección ConnectionStrings allí. Lo dejo en blanco a propósito. La cadena de conexión real se especificará en el archivo de secretos de usuario.

{
  "ConnectionStrings": {
    "Default": "<left blank>"
  }
}
Code language: JSON / JSON with Comments (json)

Su csproj ahora debería verse así:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <RootNamespace>ef_core_cli</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.4">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.4" />
  </ItemGroup>

  <ItemGroup>
    <None Update="appsettings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
  </ItemGroup>

</Project>

Code language: HTML, XML (xml)

Agregue los secretos de usuario y anule la cadena de conexión

Ejecute lo siguiente en la Consola del administrador de paquetes (Ver> Otras ventanas> Consola del administrador de paquetes).

Install-Package Microsoft.Extensions.Configuration.UserSecrets
Code language: PowerShell (powershell)

Nota:El paquete UserSecrets ya contiene Microsoft.Extensions.Configuration.Json, por lo que no necesita agregarlo por separado.

Haga clic derecho en el proyecto> haga clic en Administrar secretos de usuario .
Esto crea el archivo secrets.json y lo abre.
Ahora puede anular la cadena de conexión de appsettings poniéndola en secrets.json:

{
  "ConnectionStrings": {
    "Default": "Server=SQL_SERVER_INSTANCE_NAME;Database=StreamingService;Integrated Security=true"
  }
}
Code language: JSON / JSON with Comments (json)

Su archivo csproj ahora debería tener la información de secretos de usuario:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <RootNamespace>ef_core_cli</RootNamespace>
    <UserSecretsId>9bc52419-f971-411a-91e7-47ecdfb428da</UserSecretsId>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.4">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.4" />
    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="5.0.0" />
  </ItemGroup>

  <ItemGroup>
    <None Update="appsettings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
  </ItemGroup>

</Project>

Code language: HTML, XML (xml)

Obtener la cadena de conexión con ConfigurationBuilder

Ahora use ConfigurationBuilder para obtener la cadena de conexión:

using Microsoft.Extensions.Configuration;

class Program
{
	static void Main(string[] args)
	{
		var config = new ConfigurationBuilder()
			.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
			.AddJsonFile("appsettings.json")
			.AddUserSecrets<Program>()
			.Build();


		var connectionString = config.GetConnectionString("Default");

		Console.WriteLine(connectionString);
	}
}
Code language: C# (cs)

Ejecute el código. Debería generar la cadena de conexión del archivo de secretos de usuario:

Server=SQL_SERVER_INSTANCE_NAME;Database=StreamingService;Integrated Security=trueCode language: plaintext (plaintext)

Nota:si la cadena de conexión no se anula en secrets.json, extraerá la cadena de conexión de appsettings.json en su lugar.

Crear la base de datos

Ahora que tiene el DbContext, un modelo y una forma de obtener la cadena de conexión, puede usar dotnet ef para crear la base de datos.

Este es un proceso de dos pasos. Primero crea una "migración" de base de datos y luego la aplica. Esto tendrá más sentido cuando realice los pasos a continuación.

Añadir una fábrica de contexto en tiempo de diseño

Cuando use dotnet ef para crear la migración, buscará una clase DbContext sin parámetros. Si eso no existe, buscará una implementación de IDesignTimeDbContextFactory. Después de eso, comienza a complicarse cada vez más.

La solución más sencilla es implementar IDesignTimeDbContextFactory. Esto le da control total sobre qué objeto de contexto usa dotnet ef cuando crea migraciones.

using Microsoft.EntityFrameworkCore.Design;
using Microsoft.Extensions.Configuration;

public class DesignTimeContextFactory : IDesignTimeDbContextFactory<StreamingServiceContext>
{
	public StreamingServiceContext CreateDbContext(string[] args)
	{
		var config = new ConfigurationBuilder()
			.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
			.AddJsonFile("appsettings.json")
			.AddUserSecrets<Program>()
			.Build();


		var connectionString = config.GetConnectionString("Default");

		return new StreamingServiceContext(connectionString);
	}
}
Code language: C# (cs)

Crear migración de base de datos

Para crear una migración de base de datos, ejecute el siguiente comando (desde el directorio del proyecto):

dotnet ef migrations add Database_v0
Code language: PowerShell (powershell)

Esto agregará una carpeta /Migraciones/ a su proyecto y creará tres archivos fuente de migración:

20210314124406_Base de datos_v0.cs
20210314124406_Database_v0.Designer.cs
StreamingServiceContextModelSnapshot.cs

Nota:dotnet ef crea los archivos de migración con una marca de tiempo en el nombre.

Estos archivos de migración contienen la lógica para crear la base de datos. Eche un vistazo a 20210314124406_Database_v0.cs:

public partial class Database_v0 : Migration
{
	protected override void Up(MigrationBuilder migrationBuilder)
	{
		migrationBuilder.CreateTable(
			name: "Movies",
			columns: table => new
			{
				Id = table.Column<int>(type: "int", nullable: false)
					.Annotation("SqlServer:Identity", "1, 1"),
				Name = table.Column<string>(type: "nvarchar(500)", maxLength: 500, nullable: false),
				ReleaseYear = table.Column<int>(type: "int", nullable: false),
				Description = table.Column<string>(type: "nvarchar(500)", maxLength: 500, nullable: false),
				RuntimeMinutes = table.Column<int>(type: "int", nullable: false)
			},
			constraints: table =>
			{
				table.PrimaryKey("PK_Movies", x => x.Id);
			});
	}

	protected override void Down(MigrationBuilder migrationBuilder)
	{
		migrationBuilder.DropTable(
			name: "Movies");
	}
}
Code language: C# (cs)

Aplicar la migración de la base de datos para crear la base de datos

Suponiendo que está en un entorno de desarrollo, hay dos opciones para aplicar la migración:use dotnet ef o use context.Database.Migrate().

Nota:La discusión de las estrategias de implementación de producción está fuera del alcance de este artículo.

Opción 1:aplicar la migración mediante dotnet ef

Para aplicar la última migración, ejecute lo siguiente (desde el directorio del proyecto):

dotnet ef database update
Code language: PowerShell (powershell)

Si su base de datos no existe, la creará y luego aplicará la última migración. También puede especificar qué migración utilizar.

Esta opción funciona si estás en un entorno de desarrollo y tienes el directorio del proyecto disponible.

Opción 2:aplicar la migración desde el código

Puede llamar a context.Database.Migrate() y aplicará la última migración. Si su base de datos no existe, la creará.

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;

class Program
{
	static void Main(string[] args)
	{
		var config = new ConfigurationBuilder()
			.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
			.AddJsonFile("appsettings.json")
			.AddUserSecrets<Program>()
			.Build();


		using (var context = new StreamingServiceContext(config.GetConnectionString("Default")))
		{
			context.Database.Migrate();
		}
	}
}
Code language: C# (cs)

Usar la base de datos

Ahora que tiene la base de datos creada, puede comenzar a usarla.

Si no está familiarizado con el uso de EF Core para ejecutar consultas, le sugiero que experimente con él en una aplicación de consola independiente. Escribiré más artículos sobre cómo usar EF Core, pero por ahora, aquí hay un ejemplo de cómo insertar un registro en la base de datos:

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;

class Program
{
	static void Main(string[] args)
	{
		var config = new ConfigurationBuilder()
			.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
			.AddJsonFile("appsettings.json")
			.AddUserSecrets<Program>()
			.Build();


		using (var context = new StreamingServiceContext(config.GetConnectionString("Default")))
		{
			context.Database.Migrate();

			context.Add(new Movie 
			{ 
			   Name = "John Wick",
			   Description = "A revenge-seeking assassin goes after EVERYONE",
			   ReleaseYear = 2014,
			   RuntimeMinutes = 101
			});
			context.SaveChanges();
		}
	}
}
Code language: C# (cs)

Si busca en la base de datos, puede ver que este registro se insertó en la tabla Películas.

Código fuente en GitHub

El código fuente que se muestra en este artículo está disponible en GitHub. Si usa el código de este repositorio, asegúrese de instalar dotnet ef para que pueda agregar/aplicar migraciones.