Bien démarrer avec EF Core sur une application console .NET Core avec une nouvelle base de donnéesGetting Started with EF Core on .NET Core Console App with a New database

Dans cette procédure pas à pas, vous allez créer une application console .NET Core qui exécute l’accès aux données de base d’une base de données SQLite à l’aide d’Entity Framework Core.In this walkthrough, you will create a .NET Core console app that performs basic data access against a SQLite database using Entity Framework Core. Vous utiliserez des migrations pour créer la base de données à partir de votre modèle.You will use migrations to create the database from your model. Consultez ASP.NET Core - Nouvelle base de données pour une version de Visual Studio utilisant ASP.NET Core MVC.See ASP.NET Core - New database for a Visual Studio version using ASP.NET Core MVC.

Conseil

Vous pouvez afficher cet exemple sur GitHub.You can view this article's sample on GitHub.

PrérequisPrerequisites

Pour effectuer cette procédure pas à pas, vous devez satisfaire les prérequis suivants :The following prerequisites are needed to complete this walkthrough:

  • Un système d’exploitation prenant en charge .NET CoreAn operating system that supports .NET Core.
  • Le Kit SDK .NET Core 2.0 (bien que les instructions puissent être utilisées pour créer une application avec une version précédente avec très peu de modifications)The .NET Core SDK 2.0 (although the instructions can be used to create an application with a previous version with very few modifications).

Créer un projetCreate a new project

  • Créez un dossier ConsoleApp.SQLite pour votre projet et utilisez la commande dotnet pour la renseigner avec une application .NET Core.Create a new ConsoleApp.SQLite folder for your project and use the dotnet command to populate it with a .NET Core app.
mkdir ConsoleApp.SQLite
cd ConsoleApp.SQLite/
dotnet new console

Installer Entity Framework CoreInstall Entity Framework Core

Pour utiliser EF Core, installez le package pour le ou les fournisseurs de bases de données à cibler.To use EF Core, install the package for the database provider(s) you want to target. Cette procédure pas à pas utilise SQLite.This walkthrough uses SQLite. Pour obtenir la liste des fournisseurs disponibles, consultez Fournisseurs de bases de données.For a list of available providers see Database Providers.

  • Installez Microsoft.EntityFrameworkCore.Sqlite et Microsoft.EntityFrameworkCore.Design.Install Microsoft.EntityFrameworkCore.Sqlite and Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Microsoft.EntityFrameworkCore.Design
  • Modifiez manuellement ConsoleApp.SQLite.csproj pour ajouter un élément DotNetCliToolReference à Microsoft.EntityFrameworkCore.Tools.DotNet :Manually edit ConsoleApp.SQLite.csproj to add a DotNetCliToolReference to Microsoft.EntityFrameworkCore.Tools.DotNet:

    <ItemGroup>
      <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
    </ItemGroup>
    

ConsoleApp.SQLite.csproj doit désormais avoir le contenu suivant :ConsoleApp.SQLite.csproj should now contain the following:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.0</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.0.0" />
  </ItemGroup>
</Project>

Remarque : les numéros de version ci-dessus étaient corrects au moment de cette publication.Note: The version numbers used above were correct at the time of publishing.

  • Exécutez dotnet restore pour installer les nouveaux packages.Run dotnet restore to install the new packages.

Créer le modèleCreate the model

Définissez le contexte et les classes d’entité qui composeront le modèle.Define a context and entity classes that make up your model.

  • Créez un nouveau fichier Model.cs avec le contenu suivant.Create a new Model.cs file with the following contents.
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;

namespace ConsoleApp.SQLite
{
    public class BloggingContext : DbContext
    {
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite("Data Source=blogging.db");
        }
    }

    public class Blog
    {
        public int BlogId { get; set; }
        public string Url { get; set; }

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

    public class Post
    {
        public int PostId { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }

        public int BlogId { get; set; }
        public Blog Blog { get; set; }
    }
}

Conseil : dans une application réelle, vous placeriez chaque classe dans un fichier distinct et la chaîne de connexion dans un fichier de configuration.Tip: In a real application you would put each class in a separate file and put the connection string in a configuration file. Pour simplifier le didacticiel, nous plaçons tout dans un même fichier.To keep the tutorial simple, we are putting everything in one file.

Créer la base de donnéesCreate the database

Une fois que vous avez un modèle, vous pouvez utiliser des migrations pour créer une base de données.Once you have a model, you can use migrations to create a database.

  • Exécutez dotnet ef migrations add InitialCreate pour générer automatiquement un modèle de migration et créer l’ensemble initial de tables du modèle.Run dotnet ef migrations add InitialCreate to scaffold a migration and create the initial set of tables for the model.
  • Exécutez dotnet ef database update pour appliquer la nouvelle migration à la base de données.Run dotnet ef database update to apply the new migration to the database. Cette commande crée la base de données avant d’appliquer des migrations.This command creates the database before applying migrations.

Note

Durant l’utilisation de chemins d’accès relatifs avec SQLite, le chemin d’accès dépend de l’assembly principal de l’application.When using relative paths with SQLite, the path will be relative to the application's main assembly. Dans cet exemple, le fichier binaire principal est bin/Debug/netcoreapp2.0/ConsoleApp.SQLite.dll, de sorte que la base de données SQLite se trouvera dans bin/Debug/netcoreapp2.0/blogging.db.In this sample, the main binary is bin/Debug/netcoreapp2.0/ConsoleApp.SQLite.dll, so the SQLite database will be in bin/Debug/netcoreapp2.0/blogging.db.

Utiliser le modèleUse your model

  • Ouvrez le fichier Program.cs et remplacez le contenu par le code suivant :Open Program.cs and replace the contents with the following code:

    using System;
    
    namespace ConsoleApp.SQLite
    {
        public class Program
        {
            public static void Main()
            {
                using (var db = new BloggingContext())
                {
                    db.Blogs.Add(new Blog { Url = "http://blogs.msdn.com/adonet" });
                    var count = db.SaveChanges();
                    Console.WriteLine("{0} records saved to database", count);
    
                    Console.WriteLine();
                    Console.WriteLine("All blogs in database:");
                    foreach (var blog in db.Blogs)
                    {
                        Console.WriteLine(" - {0}", blog.Url);
                    }
                }
            }
        }
    }
    
  • Testez l’application :Test the app:

    dotnet run

    Un blog est enregistré dans la base de données et les détails de tous les blogs s’affichent dans la console.One blog is saved to the database and the details of all blogs are displayed in the console.

    ConsoleApp.SQLite>dotnet run
    1 records saved to database
    
    All blogs in database:
    - http://blogs.msdn.com/adonet
    

Modification du modèle :Changing the model:

  • Si vous apportez des modifications au modèle, vous pouvez utiliser la commande dotnet ef migrations add pour générer automatiquement un nouveau modèle de migration pour appliquer les modifications du schéma correspondantes à la base de données.If you make changes to your model, you can use the dotnet ef migrations add command to scaffold a new migration to make the corresponding schema changes to the database. Après avoir vérifié le code de modèle généré automatiquement (et effectué toutes les modifications nécessaires), vous pouvez utiliser la commande dotnet ef database update pour appliquer les modifications à la base de données.Once you have checked the scaffolded code (and made any required changes), you can use the dotnet ef database update command to apply the changes to the database.
  • EF utilise une table __EFMigrationsHistory dans la base de données pour identifier les migrations qui ont déjà été appliquées à la base de données.EF uses a __EFMigrationsHistory table in the database to keep track of which migrations have already been applied to the database.
  • SQLite ne prend pas en charge toutes les migrations (modifications du schéma) en raison des limitations de SQLite.SQLite does not support all migrations (schema changes) due to limitations in SQLite. Consultez Limitations de SQLite.See SQLite Limitations. Pour tout nouveau développement, il est préférable de supprimer la base de données et d’en créer une nouvelle plutôt que d’utiliser des migrations quand votre modèle est modifié.For new development, consider dropping the database and creating a new one rather than using migrations when your model changes.

Ressources supplémentairesAdditional Resources