Modelo Nano ASP.NET para SaaS
Credenciais de administrador (todos os locatários): admin@email.com / Password123!
Os dados de amostra são reiniciados a cada hora

Guia do Entity Framework no .NET | Descubra todo o potencial dos ORMs, das expressões lambda do LINQ e das migrações | 5 perguntas-chave em entrevistas de emprego

Ryan Lewis
29 de novembro de 2024

Meu primeiro projeto no mundo real foi um aplicativo para desktop do Windows. Ele contava com um servidor de banco de dados local (um computador guardado no depósito do diretor financeiro) e foi desenvolvido usando os mesmos métodos que eu havia aprendido nas aulas de programação da universidade. Para o acesso aos dados, escrevi instruções SQL, e o esquema era gerenciado separadamente, sem controle de versão.

Apesar de ter sido um sucesso para a empresa, o desenvolvimento foi doloroso e, sem dúvida, um pesadelo para quem herdou o código quando eu saí! Antes de começar meu segundo projeto no mundo real, eu sabia que precisava aprender sobre ORMs. Se você está começando agora a aprender sobre ORMs, ótimo, porque saber como usá-los levará suas habilidades a outro nível. Este é mais uma visão geral do que um guia passo a passo, com perguntas de entrevista no final.

Existem ORMs para todos os tipos de frameworks de desenvolvimento web. No mundo do .NET, porém, o Entity Framework Core é o principal. O Entity Framework já existe há anos, desde 2008, e é mantido pela Microsoft. Outro ORM que vale a pena mencionar para o .NET é o Dapper, mas o Entity Framework será a escolha padrão para muitos, pois é muito bom. Os ORMs lidam com a persistência no back-end; você pode usar o Entity Framework sem o MVC. O restante do projeto da sua aplicação não depende do ORM.

Se eu tivesse que resumir o que os ORMs fazem em uma frase, seria esta: os ORMs cuidam de todo o trabalho tedioso relacionado às interações com um banco de dados. Aqui estão algumas das principais vantagens que o uso de um ORM como o Entity Framework Core pode oferecer:

A primeira grande vantagem é que, em vez de escrever instruções SQL diretas, você pode usar o LINQ. O LINQ (Language Integrated Query) é um recurso do .NET que utiliza expressões lambda para fornecer uma sintaxe padronizada, semelhante à do SQL, para consultar e transformar dados em diferentes fontes, como coleções, bancos de dados e XML.

As mesmas expressões lambda que você escreve para manipular Lists / Enumerable / Collections são usadas para recuperar dados de um banco de dados. Algumas vantagens são que você não precisa parametrizar strings e conta com o IntelliSense e a segurança de tipos. No geral, o LINQ é muito mais fácil de escrever do que o SQL puro. Nos bastidores, o Entity Framework traduz as instruções LINQ em SQL puro, não importa quão complexas sejam, com subconsultas, uniões, junções etc. Para ilustrar, aqui está um exemplo simples de como você poderia usar uma expressão lambda do LINQ para selecionar o valor máximo com o Entity Framework Core

// Supondo que 'context' seja seu DbContext e 'Products' seja seu DbSet
var maxValue = contexto.Produtos
    .Max(e => e.Nome da coluna);

E aqui está uma instrução `lambda select` que seria traduzida pelo ORM em SQL bruto

SELECT MAX(Nome da coluna) DA categoria Produtos

Agora, um exemplo mais complexo (retirado de um dos meus projetos) de uma instrução LINQ:

var consulta = _contexto.Políticas
    .Incluir(x => x.Estações do ano)
    .Incluir(x => x.Itinerário e Produtos).ThenInclude(x => x.Produto)
    .Incluir(x => x.Itinerário e Produtos).ThenInclude(x => x.Produto.Quartos);

Como SQL puro, nossa!

SELECT 
    p.*,    -- Selecionar todos colunas de o Políticas tabela
    s.*,    -- Selecionar todos colunas de o Estações do ano tabela
    ip.*,   -- Selecionar todos colunas de o Itinerário e Produtos tabela
    pr.*,   -- Selecionar todos colunas de o Produtos tabela
    r.*     -- Selecionar todos colunas de o Quartos tabela
DE Políticas p
ESQUERDA PARTICIPE Estações do ano s LIGADO p.Id = s.PolicyId
ESQUERDA PARTICIPE Itinerário e Produtos ip LIGADO p.Id = ip.PolicyId
ESQUERDA PARTICIPE Produtos pr LIGADO ip.ID do produto = pr.Id
ESQUERDA PARTICIPE Quartos r LIGADO pr.Id = r.ID do produto
ORDEM POR p.Data de início;

Outra vantagem é que, ao utilizar migrações e a abordagem “code-first”, o esquema do seu banco de dados passará a estar sob controle de versão.

No início, o desenvolvimento “code-first” não fazia muito sentido para mim. Eu sempre criava um banco de dados separadamente: criava as tabelas, projetava o esquema etc. em uma ferramenta de banco de dados como o MySQL Workbench ou o SSMS. O aplicativo não tinha nenhum conhecimento sobre o banco de dados, além de uma string de conexão. Se o nome de uma tabela fosse alterado no banco de dados, uma instrução SQL que a referenciasse no código simplesmente deixaria de funcionar. Também não havia como acompanhar as alterações no esquema. Com o código, eu tinha controle de versão, mas não com o banco de dados.

As migrações “code-first” resolveram todos esses problemas. O ponto fundamental a se entender é que você usará código para projetar o banco de dados, e não uma ferramenta de banco de dados separada.

O Entity Framework utiliza uma classe chamada contexto de banco de dados (DbContext). Dentro dessa classe de contexto, há referências a todas as entidades que você rastreará como tabelas no banco de dados (DbSets). Essas classes de entidade são classes simples do modelo C# com propriedades que definem as colunas.

Por exemplo, criar uma classe chamada “Produtos” e adicioná-la como uma DbSet para o DbContext resultará na criação de uma tabela de produtos no banco de dados. Para criar colunas, basta defini-las como propriedades na classe. O Entity Framework irá traduzir o Tipos C# para tipos de bancos de dados para você. A string essa propriedade irá gerar um nvarchar coluna no SQL Server, por exemplo. O EF também oferece anotações de dados para um controle ainda maior sobre os atributos das colunas.

público classe Produto
{
    público int Id { obter; definir; }
    público string Nome { obter; definir; }
    público string Descrição { obter; definir; }

    // Chave estrangeira para a relação
    público int ID do fornecedor { obter; definir; }
    
    // Navegação de volta à propriedade “Fornecedor”
    público Fornecedor Fornecedor { obter; definir; }
}

As relações entre tipos de entidade são definidas de acordo com a convenção a seguir. Existem convenções para todos os tipos de relações: um-para-muitos, um-para-um e muitos-para-muitos. Veja a seguir como uma relação típica de um-para-muitos pode se apresentar no Entity Framework:

público classe Fornecedor
{
    público int Id { obter; definir; }
    público string Nome { obter; definir; }
    público string Endereço { obter; definir; }
    público string Telefone { obter; definir; }

    // Propriedade de navegação da coleção para uma relação um-para-muitos
    público Lista<Produto> Produtos { obter; definir; }
}

Qualquer propriedade cujo nome corresponda ao de uma tabela existente, com o ID acrescentado, será configurada como chave estrangeira por convenção. A adição de propriedades de navegação do tipo ICollection é opcional, mas incluí-las permitirá que o Entity Framework recupere dados relacionados sempre que você criar suas consultas LINQ. Os dados das tabelas relacionadas podem ser carregados de forma diferida (lazy loading) ou antecipada (eager loading) para otimizar o desempenho.

Apesar da configuração baseada em convenções do Entity Framework ser tão fácil de usar, às vezes você pode querer um pouco mais de controle. Por esse motivo, o EF permite que você configure tudo de forma totalmente explícita, se necessário. Nas classes de entidade ou na classe de contexto do banco de dados, é possível definir configurações explícitas usando expressões fluentes.

Como o mapa completo do banco de dados é definido como código em suas classes de entidade, o EF pode manipular dados em um banco de dados com a mesma facilidade com que você transformaria dados dentro de um objeto `List` ou `Enumerable`.

Depois de definirmos todas as classes de entidade e referenciá-las na classe de contexto do banco de dados, podemos criar nossa primeira migração para aplicar efetivamente as alterações ao banco de dados. Nesse momento, se executássemos o aplicativo, não haveria nenhum banco de dados, nem nosso aplicativo criaria um. Na verdade, receberíamos vários erros também, pois o EF consegue detectar se há alguma diferença entre o banco de dados e seus modelos.

Uma migração é como um instantâneo do estado evolutivo do seu esquema. Uma migração é uma classe gerada automaticamente pelas ferramentas de tempo de projeto do Entity Framework. Pela linha de comando, podemos usar o comando adicionar migração para fazer isso. Se você não definir um diretório de saída específico, o EF criará uma pasta chamada Migrações no seu projeto e mantenha as classes lá. Essas migrações permanecerão pendentes até que sejam efetivamente aplicadas por meio do atualizar-banco-de-dados comando.

O código gerado nas classes de migração contém scripts SQL. Quando aplicado com atualizar-banco-de-dados, esses comandos geram um esquema que corresponde ao projeto das suas classes de entidade no banco de dados de destino. Se o banco de dados não existir, o EF criará um novo para você, usando o nome que você definiu na string de conexão padrão. Essas classes de migração contêm duas seções de código: para cima e para baixo. Os comandos no para cima O método será executado sempre que você aplicar uma migração; os comandos no para baixo Esse método será executado caso você queira reverter para um estado anterior da migração. Veja a seguir como poderia ser a migração das tabelas `Product` e `Supplier` (supondo que você tenha feito uma única migração para ambas as tabelas):

público parcial classe InicializarCriação : Migração
{
    protegido substituir nulo Para cima(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            nome: "Fornecedores",
            colunas: tabela => novo
            {
                Id = tabela.Coluna<int>(tipo: "int", nulo: false)
                    .Anotação("SqlServer:Identity", "1, 1"),
                Nome = tabela.Coluna<string>(tipo: "nvarchar(max)", nulo: verdadeiro),
                Endereço = tabela.Coluna<string>(tipo: "nvarchar(max)", nulo: verdadeiro),
                Telefone = tabela.Coluna<string>(tipo: "nvarchar(max)", nulo: verdadeiro)
            },
            restrições: tabela =>
            {
                tabela.Chave Primária("PK_Fornecedores", x => x.Id);
            });

        migrationBuilder.CreateTable(
            nome: "Produtos",
            colunas: tabela => novo
            {
                Id = tabela.Coluna<int>(tipo: "int", nulo: false)
                    .Anotação("SqlServer:Identity", "1, 1"),
                Nome = tabela.Coluna<string>(tipo: "nvarchar(max)", nulo: verdadeiro),
                Descrição = tabela.Coluna<string>(tipo: "nvarchar(max)", nulo: verdadeiro),
                ID do fornecedor = tabela.Coluna<int>(tipo: "int", nulo: false)
            },
            restrições: tabela =>
            {
                tabela.Chave Primária("PK_Produtos", x => x.Id);
                tabela.Chave Estrangeira(
                    nome: "FK_Produtos_Fornecedores_IdFornecedor",
                    coluna: x => x.ID do fornecedor,
                    tabela principal: "Fornecedores",
                    coluna principal: "Id",
                    onDelete: Ação Referencial.Cascata);
            });

        migrationBuilder.CreateIndex(
            nome: "IX_Produtos_IdDoFornecedor",
            tabela: "Produtos",
            coluna: "ID do fornecedor");
    }

    protegido substituir nulo Para baixo(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(
            nome: "Produtos");

        migrationBuilder.DropTable(
            nome: "Fornecedores");
    }
}

O Entity Framework rastreia as alterações por meio de uma tabela no banco de dados e de uma classe de instantâneo do modelo de contexto do banco de dados na pasta de migrações. Cada nova migração gerará apenas o código necessário para aplicar as alterações entre uma migração e a seguinte. Por exemplo, digamos que você tenha criado uma migração inicial para um aplicativo que possuía uma entidade `Product`. Posteriormente, você adiciona outra entidade, `Supplier`. No momento em que você criar uma nova migração para `Supplier`, essa nova migração conterá apenas código relacionado à entidade `Supplier` e a quaisquer novas relações. Quando executamos o atualizar-banco-de-dados comando, todas as migrações pendentes serão aplicadas em ordem cronológica.

Como essas classes de migração ficam armazenadas junto com o aplicativo no controle de versão, qualquer pessoa que baixar seu repositório posteriormente poderá recriar o banco de dados exatamente como ele deve estar no momento. Isso é uma grande mudança para quem precisa trabalhar em equipe ou simplesmente deseja manter um mínimo de sanidade.

As migrações também são extremamente importantes em aplicativos multilocatários. Ao criar novos locatários dinamicamente com um banco de dados separado, são essas migrações que tornam isso possível. A multilocação é um tema um pouco mais avançado, mas é essencial se você deseja desenvolver aplicativos SaaS para o grande público. Se esse é o seu objetivo, o Nano ASP.NET Boilerplate é um modelo de projeto adaptável que pode ser usado para gerar todos os tipos de novos projetos, incluindo aplicativos SaaS multilocatários.  

Este artigo abordou apenas os conceitos básicos do que ferramentas como o Entity Framework são capazes de fazer. Conhecer as migrações “code-first” e o LINQ é fundamental, mas há muito mais a ser explorado. É possível executar código sempre que ocorrem alterações ao salvar, implementar filtros de consulta globais e até mesmo definir configurações diferentes para cada solicitação.

A persistência de dados é um tema muito amplo, e os ORMs são apenas uma parte desse tema. Quando usados em conjunto com padrões como repositório genérico e especificação (especialmente a especificação Ardalis), você começará a explorar todo o potencial do ASP.NET e a construir aplicativos verdadeiramente escaláveis. O Nano boilerplate é um modelo de projeto que desenvolvemos, combinando apenas o melhor desses padrões e práticas. Use-o em projetos ilimitados e gere soluções bem arquitetadas instantaneamente. Ele é mantido sempre atualizado e vem com três projetos de interface do usuário.

Espero que este artigo tenha servido como um guia útil para o mundo dos ORMs e, em particular, do Entity Framework Core. Há uma enorme quantidade de documentação técnica e tutoriais sobre o Entity Framework disponíveis gratuitamente na Microsoft e em outras fontes na internet!

1. O que é o Entity Framework e quais são suas principais vantagens?

Objetivo: Avaliar a compreensão do candidato sobre o objetivo principal e os benefícios da EF.
Resposta esperada: O Entity Framework é um mapeador objeto-relacional (ORM) para .NET que simplifica as operações com bancos de dados, permitindo que os desenvolvedores trabalhem com entidades de banco de dados por meio de objetos C#. As vantagens incluem:

  • Menor necessidade de escrever SQL bruto.
  • Consultas fortemente tipadas para garantir a segurança em tempo de compilação.
  • Suporte integrado ao LINQ para consultar dados.
  • Abordagens de desenvolvimento “Database-First”, “Code-First” e “Model-First”.

2. Explique as diferenças entre as abordagens “Code-First”, “Database-First” e “Model-First” no EF.

Objetivo: Para avaliar o conhecimento sobre os diferentes fluxos de trabalho do EF e seus casos de uso.
Resposta esperada:

  • Code-First: Defina a estrutura do banco de dados usando as classes C#. O EF gera o esquema do banco de dados com base no modelo. Ideal para projetos que começam do zero.
  • Abordagem “Database-First”: Comece com um banco de dados já existente, e o EF gera o modelo e o contexto a partir do esquema. Adequado para bancos de dados legados.
  • Modelo em primeiro lugar: Defina o banco de dados visualmente em um designer, e o EF gera o esquema e as classes. Útil para projetos que exigem uma abordagem visual.

3. Qual é a diferença entre DbSet e DbContext no Entity Framework?

Objetivo: Para avaliar a compreensão do candidato sobre os principais componentes da EF.
Resposta esperada:

  • DbContext: A principal classe responsável pela interação com o banco de dados. Ela gerencia a conexão, acompanha as alterações e lida com as operações CRUD.
  • DbSet: Representa um conjunto de entidades de um tipo específico que o EF rastreia e com as quais interage no banco de dados. É usado para consultar e salvar instâncias de entidades.

4. O que são carregamento antecipado, preguiçoso e explícito no EF, e quando se deve usar cada um deles?

Objetivo: Avaliar a compreensão das estratégias de carregamento de dados e da otimização de desempenho.
Resposta esperada:

  • Carregamento antecipado: Carrega as entidades relacionadas à entidade principal em uma única consulta. Use essa opção quando souber que precisará dos dados relacionados.
  • Carregamento diferido: Carrega as entidades relacionadas somente quando são acessadas. É uma boa opção para minimizar o tempo de carregamento inicial, mas pode resultar em várias consultas (problema N+1).
  • Carregamento explícito: Carregue manualmente os dados relacionados usando .Load(). Útil para um controle preciso sobre a obtenção de dados.

5. Como o EF lida com a concorrência e como é possível resolver conflitos de concorrência?

Objetivo: Avaliar o conhecimento sobre gerenciamento de concorrência no EF.
Resposta esperada: O EF lida com a concorrência usando um ConcurrencyToken. Quando dois usuários tentam atualizar os mesmos dados simultaneamente, ocorre um DbUpdateConcurrencyException é lançada.

  • Para resolver conflitos, use Controle de Concorrência Otimista com propriedades como a coluna RowVersion.
  • As opções para resolver conflitos incluem a prioridade do cliente, a prioridade da loja ou uma lógica de fusão personalizada.

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Precisa de um modelo ASP.NET para desenvolver seu próximo MVP?
Confira o projeto modelo Nano ASP.NET para SaaS multilocatário e economize semanas ou meses de tempo de desenvolvimento.
Saiba mais