Configurar um DbContextConfiguring a DbContext

Este artigo mostra os padrões básicos para a configuração de um DbContext por meio de um DbContextOptions para se conectar a um banco de dados usando um provedor específico do EF Core e comportamentos opcionais.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.

Configuração do tempo de design DbContextDesign-time DbContext configuration

Ferramentas de tempo de design do EF Core, como migrações precisa ser capaz de detectar e criar uma instância de trabalho de um DbContext tipo para obter detalhes sobre os tipos de entidade e como eles são mapeados para um esquema de banco de dados do aplicativo.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. Esse processo pode ser automático, desde que a ferramenta pode criar facilmente o DbContext de tal forma que ele será configurado da mesma forma como deve ser configurado em tempo de execução.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.

Embora qualquer padrão que fornece informações de configuração necessárias para o DbContext pode funcionar em tempo de execução, as ferramentas que exigem o uso de um DbContext em tempo de design só pode trabalhar com um número limitado de padrões.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. Isso é abordado em mais detalhes os criação de contexto de tempo de Design seção.These are covered in more detail in the Design-Time Context Creation section.

Configurando DbContextOptionsConfiguring DbContextOptions

DbContext deve ter uma instância de DbContextOptions para realizar qualquer trabalho.DbContext must have an instance of DbContextOptions in order to perform any work. O DbContextOptions instância carrega as informações de configuração, como:The DbContextOptions instance carries configuration information such as:

  • O provedor de banco de dados a ser usado, normalmente selecionado ao invocar um método como UseSqlServer ou UseSqliteThe database provider to use, typically selected by invoking a method such as UseSqlServer or UseSqlite
  • Qualquer cadeia de caracteres de conexão necessárias ou o identificador da instância do banco de dados, normalmente passado como um argumento para o método de seleção de provedor mencionado acimaAny necessary connection string or identifier of the database instance, typically passed as an argument to the provider selection method mentioned above
  • Seletores qualquer comportamento opcional do nível de provedor, normalmente também encadeadas dentro da chamada para o método de seleção de provedorAny provider-level optional behavior selectors, typically also chained inside the call to the provider selection method
  • Qualquer gerais seletores de comportamento do EF Core, encadeados normalmente depois ou antes que o método de seletor de provedorAny general EF Core behavior selectors, typically chained after or before the provider selector method

O exemplo a seguir configura a DbContextOptions para usar o provedor do SQL Server, uma conexão contidos em de connectionString variável, um tempo limite de comando de nível de provedor e um seletor de comportamento do EF Core que faz com que todas as consultas executadas no DbContext sem controle por padrão: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);

Observação

Métodos de seletor de provedor e outros métodos de seletor de comportamento mencionados acima são métodos de extensão em DbContextOptions ou classes de opção específico do provedor.Provider selector methods and other behavior selector methods mentioned above are extension methods on DbContextOptions or provider-specific option classes. Para ter acesso a esses métodos de extensão que você talvez precise ter um namespace (normalmente Microsoft.EntityFrameworkCore) no escopo e incluir as dependências de pacote adicionais no projeto.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.

O DbContextOptions pode ser fornecido para o DbContext , substituindo o OnConfiguring método ou externamente por meio de um argumento do construtor.The DbContextOptions can be supplied to the DbContext by overriding the OnConfiguring method or externally via a constructor argument.

Se ambos forem usadas, OnConfiguring é aplicada por último e podem substituir as opções fornecidas para o argumento do construtor.If both are used, OnConfiguring is applied last and can overwrite options supplied to the constructor argument.

Argumento de construtorConstructor argument

Código do contexto com o construtor:Context code with constructor:

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

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

Dica

O construtor de base do DbContext também aceita a versão não genérica de DbContextOptions, mas não é recomendável usar a versão não genérica para aplicativos com vários tipos de contexto.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.

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

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 para inicializar uma DbContext que usa OnConfiguring:Application code to initialize a DbContext that uses OnConfiguring:

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

Dica

Essa abordagem não se prestam para teste, a menos que os testes de banco de dados completo de destino.This approach does not lend itself to testing, unless the tests target the full database.

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

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

AddDbContext<TContext> fará os dois é o tipo DbContext, TContexte o correspondente DbContextOptions<TContext> disponível para injeção de contêiner de serviço.AddDbContext<TContext> will make both your DbContext type, TContext, and the corresponding DbContextOptions<TContext> available for injection from the service container.

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

Adicionando o Dbcontext a injeção de dependência:Adding the 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 de DbContext que aceita DbContextOptions<TContext>.This requires adding a constructor argument to your DbContext type that accepts DbContextOptions<TContext>.

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 class MyController
{
    private readonly BloggingContext _context;

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

    ...
}

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

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

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

Ler maisMore reading