Configuration d’un DbContextConfiguring a DbContext

Cet article présente les modèles de base pour la configuration un DbContext via un DbContextOptions pour se connecter à une base de données à l’aide d’un fournisseur EF Core spécifique et les comportements facultatifs.This article shows basic patterns for configuring a DbContext via a DbContextOptions to connect to a database using a specific EF Core provider and optional behaviors.

Configuration de DbContext au moment du designDesign-time DbContext configuration

EF Core au moment du design des outils tels que migrations doivent être en mesure de détecter et de créer une instance de l’utilisation d’un DbContext type afin de collecter des informations détaillées sur les types d’entité de l’application et comment ils sont mappés à un schéma de base de données.EF Core design-time tools such as migrations need to be able to discover and create a working instance of a DbContext type in order to gather details about the application's entity types and how they map to a database schema. Ce processus peut être automatique, que l’outil peut facilement créer le DbContext de sorte qu’il sera configuré de la même façon à la façon dont elle est configurée au moment de l’exécution.This process can be automatic as long as the tool can easily create the DbContext in such a way that it will be configured similarly to how it would be configured at run-time.

Bien que n’importe quel modèle qui fournit les informations de configuration nécessaires à la DbContext peut fonctionner au moment de l’exécution, les outils qui requièrent l’utilisation un DbContext au moment du design ne fonctionnent qu’avec un nombre limité de modèles.While any pattern that provides the necessary configuration information to the DbContext can work at run-time, tools that require using a DbContext at design-time can only work with a limited number of patterns. Elles sont traitées plus en détail dans le la création du contexte au moment du Design section.These are covered in more detail in the Design-Time Context Creation section.

Configuration de DbContextOptionsConfiguring DbContextOptions

DbContext doit avoir une instance de DbContextOptions afin d’effectuer des tâches.DbContext must have an instance of DbContextOptions in order to perform any work. Le DbContextOptions instance comporte des informations de configuration telles que :The DbContextOptions instance carries configuration information such as:

  • Le fournisseur de base de données à utiliser, généralement sélectionné en appelant une méthode comme UseSqlServer ou UseSqliteThe database provider to use, typically selected by invoking a method such as UseSqlServer or UseSqlite
  • Toute chaîne de connexion nécessaires ou d’un identificateur de l’instance de la base de données, généralement passé en tant qu’argument à la méthode de sélection de fournisseur mentionnée ci-dessusAny necessary connection string or identifier of the database instance, typically passed as an argument to the provider selection method mentioned above
  • Tous les sélecteurs comportement facultatif au niveau du fournisseur, généralement également chaînés à l’intérieur de l’appel à la méthode de sélection du fournisseurAny provider-level optional behavior selectors, typically also chained inside the call to the provider selection method
  • N’importe quel sélecteurs de comportement générales EF Core, généralement chaînées après ou avant la méthode de sélection du fournisseurAny general EF Core behavior selectors, typically chained after or before the provider selector method

L’exemple suivant configure le DbContextOptions pour utiliser le fournisseur SQL Server, une connexion contenue dans le connectionString variable, un délai d’expiration au niveau du fournisseur de commande et un sélecteur de comportement d’EF Core qui effectue toutes les requêtes exécutées dans le DbContext NoTracking par défaut :The following example configures the DbContextOptions to use the SQL Server provider, a connection contained in the connectionString variable, a provider-level command timeout, and an EF Core behavior selector that makes all queries executed in the DbContext no-tracking by default:

optionsBuilder
    .UseSqlServer(connectionString, providerOptions=>providerOptions.CommandTimeout(60))
    .UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);

Note

Méthodes de sélecteur de fournisseur et d’autres méthodes de sélecteur de comportement mentionnés ci-dessus sont des méthodes d’extension sur DbContextOptions ou classes d’option spécifique au fournisseur.Provider selector methods and other behavior selector methods mentioned above are extension methods on DbContextOptions or provider-specific option classes. Pour accéder à ces méthodes d’extension que vous devrez peut-être disposer d’un espace de noms (généralement Microsoft.EntityFrameworkCore) dans l’étendue et inclure les dépendances de package supplémentaires dans le projet.In order to have access to these extension methods you may need to have a namespace (typically Microsoft.EntityFrameworkCore) in scope and include additional package dependencies in the project.

Le DbContextOptions peuvent être fournis à la DbContext en substituant le OnConfiguring méthode ou en externe via un argument de constructeur.The DbContextOptions can be supplied to the DbContext by overriding the OnConfiguring method or externally via a constructor argument.

Si les deux sont utilisés, OnConfiguring est appliqué en dernier et peuvent remplacer des options fournies à l’argument de constructeur.If both are used, OnConfiguring is applied last and can overwrite options supplied to the constructor argument.

Argument du constructeurConstructor argument

Code de contexte avec le constructeur :Context code with constructor:

public class BloggingContext : DbContext
{
    public BloggingContext(DbContextOptions<BloggingContext> options)
        : base(options)
    { }

    public DbSet<Blog> Blogs { get; set; }
}

Conseil

Le constructeur de base de DbContext accepte également la version non générique de DbContextOptions, mais à l’aide de la version non générique n’est pas recommandé pour les applications avec plusieurs types de contexte.The base constructor of DbContext also accepts the non-generic version of DbContextOptions, but using the non-generic version is not recommended for applications with multiple context types.

Code d’application d’initialiser à partir de l’argument du constructeur :Application code to initialize from constructor argument:

var optionsBuilder = new DbContextOptionsBuilder<BloggingContext>();
optionsBuilder.UseSqlite("Data Source=blog.db");

using (var context = new BloggingContext(optionsBuilder.Options))
{
  // do stuff
}

OnConfiguringOnConfiguring

Code de contexte avec OnConfiguring:Context code with OnConfiguring:

public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }

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

Code d’application pour initialiser un DbContext qui utilise OnConfiguring:Application code to initialize a DbContext that uses OnConfiguring:

using (var context = new BloggingContext())
{
  // do stuff
}

Conseil

Cette approche ne se prête pas au test, à moins que les tests ciblent la base de données complète.This approach does not lend itself to testing, unless the tests target the full database.

À l’aide de DbContext avec l’injection de dépendanceUsing DbContext with dependency injection

EF Core prend en charge à l’aide de DbContext avec un conteneur d’injection de dépendance.EF Core supports using DbContext with a dependency injection container. Votre type DbContext peut être ajouté au conteneur de service en utilisant le AddDbContext<TContext> (méthode).Your DbContext type can be added to the service container by using the AddDbContext<TContext> method.

AddDbContext<TContext> rendra à la fois votre type DbContext, TContextet le correspondantes DbContextOptions<TContext> disponibles pour l’injection de code à partir du conteneur de service.AddDbContext<TContext> will make both your DbContext type, TContext, and the corresponding DbContextOptions<TContext> available for injection from the service container.

Consultez lire plus ci-dessous pour plus d’informations sur l’injection de dépendances.See more reading below for additional information on dependency injection.

Ajout de la Dbcontext pour l’injection de dépendances :Adding the Dbcontext to dependency injection:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<BloggingContext>(options => options.UseSqlite("Data Source=blog.db"));
}

Cela nécessite l’ajout d’un argument du constructeur à votre type DbContext qui accepte DbContextOptions<TContext>.This requires adding a constructor argument to your DbContext type that accepts DbContextOptions<TContext>.

Code de contexte :Context code:

public class BloggingContext : DbContext
{
    public BloggingContext(DbContextOptions<BloggingContext> options)
      :base(options)
    { }

    public DbSet<Blog> Blogs { get; set; }
}

Code d’application (dans ASP.NET Core) :Application code (in ASP.NET Core):

public class MyController
{
    private readonly BloggingContext _context;

    public MyController(BloggingContext context)
    {
      _context = context;
    }

    ...
}

Code d’application (à l’aide de ServiceProvider directement, moins fréquent) :Application code (using ServiceProvider directly, less common):

using (var context = serviceProvider.GetService<BloggingContext>())
{
  // do stuff
}

var options = serviceProvider.GetService<DbContextOptions<BloggingContext>>();

Lire plusMore reading