Configurando um DbContextConfiguring a DbContext

Este artigo mostra os padrões para configurar um DbContext com DbContextOptions.This article shows patterns for configuring a DbContext with DbContextOptions. Opções são usadas principalmente para selecionar e configurar o repositório de dados.Options are primarily used to select and configure the data store.

Configurando DbContextOptionsConfiguring DbContextOptions

DbContextdeve ter uma instância de DbContextOptions para executar.DbContext must have an instance of DbContextOptions in order to execute. Isso pode ser configurado por meio da substituição OnConfiguring, ou externamente fornecido por meio de um argumento de construtor.This can be configured by overriding OnConfiguring, or supplied externally via a constructor argument.

Se ambos forem usadas, OnConfiguring é executado nas opções fornecidas, que significa que é aditivo e pode substituir opções fornecidas para o argumento de construtor.If both are used, OnConfiguring is executed on the supplied options, meaning it is additive and can overwrite options supplied to the constructor argument.

Argumento de construtorConstructor argument

Código de contexto com o construtorContext code with constructor

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

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

Dica

O construtor base do DbContext também aceita a versão não genérica de DbContextOptions.The base constructor of DbContext also accepts the non-generic version of DbContextOptions. Não é recomendável usar a versão não genérica para aplicativos com vários tipos de contexto.Using the non-generic version is not recommended for applications with multiple context types.

Código do aplicativo para inicializar a partir do argumento de construtorApplication 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

Aviso

OnConfiguringocorre por último e pode substituir opções de DI ou o construtor.OnConfiguring occurs last and can overwrite options obtained from DI or the constructor. Essa abordagem não se prestam ao teste (a menos que o banco de dados completo de destino).This approach does not lend itself to testing (unless you target the full database).

Código de contexto com 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");
    }
}

Código do aplicativo ao inicializar com OnConfiguring:Application code to initialize with OnConfiguring:

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

Usando DbContext com injeção de dependênciaUsing DbContext with dependency injection

EF oferece suporte ao uso DbContext com um contêiner de injeção de dependência.EF supports using DbContext with a dependency injection container. O tipo DbContext pode ser adicionado ao contêiner de serviço usando AddDbContext<TContext>.Your DbContext type can be added to the service container by using AddDbContext<TContext>.

AddDbContextfará com que os dois o tipo DbContext, TContext, e DbContextOptions<TContext> disponíveis para a injeção do contêiner de serviços.AddDbContext will make both your DbContext type, TContext, and DbContextOptions<TContext> available for injection from the service container.

Consulte leitura mais abaixo para obter informações sobre injeção de dependência.See more reading below for information on dependency injection.

Adicionando dbcontext a injeção de dependênciaAdding dbcontext to dependency injection

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

Isso requer a adição de um argumento do construtor para o tipo DbContext que aceita DbContextOptions.This requires adding a constructor argument to your DbContext type that accepts DbContextOptions.

Código do contexto:Context code:

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

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

Código do aplicativo (no ASP.NET Core):Application code (in ASP.NET Core):

public MyController(BloggingContext context)

Código do aplicativo (usando o provedor de serviços diretamente, menos comuns):Application code (using ServiceProvider directly, less common):

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

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

Usando oIDesignTimeDbContextFactory<TContext>Using IDesignTimeDbContextFactory<TContext>

Como alternativa para as opções acima, você também pode fornecer uma implementação de IDesignTimeDbContextFactory<TContext>.As an alternative to the options above, you may also provide an implementation of IDesignTimeDbContextFactory<TContext>. Ferramentas EF podem usar esta fábrica para criar uma instância do seu DbContext.EF tools can use this factory to create an instance of your DbContext. Isso pode ser necessário para habilitar experiências de tempo de design específicas, como as migrações.This may be required in order to enable specific design-time experiences such as migrations.

Implemente essa interface para habilitar os serviços de tempo de design para tipos de contexto que não têm um construtor padrão público.Implement this interface to enable design-time services for context types that do not have a public default constructor. Serviços de tempo de design descobrirá automaticamente implementações dessa interface que estão no mesmo assembly como o contexto de derivada.Design-time services will automatically discover implementations of this interface that are in the same assembly as the derived context.

Exemplo:Example:

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;

namespace MyProject
{
    public class BloggingContextFactory : IDesignTimeDbContextFactory<BloggingContext>
    {
        public BloggingContext CreateDbContext(string[] args)
        {
            var optionsBuilder = new DbContextOptionsBuilder<BloggingContext>();
            optionsBuilder.UseSqlite("Data Source=blog.db");

            return new BloggingContext(optionsBuilder.Options);
        }
    }
}

Ler maisMore reading