Entity Framework Core

Entity Framework Core com MySQL

Este artigo será bem prático, mostrando como se conectar a uma base MySQL no Entity Framework Core.

C# (C Sharp) - Introdução ao ASP.NET Core
Curso de C# (C Sharp) - Introdução ao ASP.NET Core
CONHEÇA O CURSO

Um pouco de história

Entity Framework Core é uma versão leve, extensível e multiplataforma do Entity Framework.

Criado com base no .NET Core, o Entity Core procurou manter a mesma experiência que o desenvolvedor possuia com o Entity Framework 6.X, mantendo a maioria das APIs de alto nível. Ao mesmo tempo, fazendo uso de um conjunto completamente novo de componentes.

Isso significa que mesmo mantendo parte da estrutura familiar do Entity 6.X, o Entity Core não herdou automaticamente os recursos deste framework. Uma prova disso é que quando ele foi lançado no ano passado, o framework suportava apenas os bancos de dados abaixo:

  • SQL Server;
  • SQLite;
  • Postgres;
  • SQL Server Compact;
  • E os bancos suportados pela biblioteca da DevArt (que é paga).

Mas, com um core totalmente reformulado, o Entity Core se tornou mais leve e extensível que a antiga versão da biblioteca, permitindo que novos recursos fossem adicionados com facilidade.

Agora na sua 2ª versão, o Entity Core já suporta mais bancos de dados e neste artigo veremos como utilizá-lo com uma base de dados MySQL.

Ambiente

Para este artigo, estou utilizando o ambiente abaixo:

  • NET Core SDK 2.0
  • Visual Studio Core
  • MySQL Server 5.7
  • Mac OS High Sierra

Criando o projeto

Por estar no Mac, vou criar uma aplicação console pelo terminal:

dotnet new console -o efcoremysql

E nela vou adicionar as bibliotecas abaixo:

dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Pomelo.EntityFrameworkCore.MySql

E para adicionar os comandos do Entity Core no terminal, é necessário adicionar no arquivo de configuração do projeto (efcoremysql.csproj) a linha abaixo:

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

Com isso, pode ser aplicado o restore:

dotnet restore

Configurando o acesso ao banco de dados

Por ter configurado os comandos do Entity Core para a aplicação, é possível utilizar o comando ef dbcontext scaffold para já criar um context configurado:

dotnet ef dbcontext scaffold "Server=localhost;User Id=root;Password=1234;Database=treinaweb" "Pomelo.EntityFrameworkCore.MySql" -c MyDbContext

Que possuirá o código abaixo:

public partial class MyDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (!optionsBuilder.IsConfigured)
        {
            optionsBuilder.UseMySql("Server=localhost;User Id=root;Password=1234;Database=treinaweb");
        }
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {}
}

Configurando o acesso ao banco de dados

Com o acesso ao banco configurado, podemos definir as entidades:

public class Album
{
    public int Id { get; set; }
    public string Nome { get; set; }
    public int Ano { get; set; }
    public string Observacoes { get; set; }
    public string Email { get; set; }

    public virtual List<Musica> Musicas { get; set; }
}


public class Musica
{
    public long Id { get; set; }
    public string Nome { get; set; }

    public virtual Album Album { get; set; }
}

E definí-las no Context:

public partial class MyDbContext : DbContext
{
    public DbSet<Album> Albuns { get; set; }

    public DbSet<Musica> Musicas { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (!optionsBuilder.IsConfigured)
        {
            optionsBuilder.UseMySql("Server=localhost;User Id=root;Password=1234;Database=treinaweb");
        }
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {}
}

E com isso criar uma migration:

dotnet ef migrations add InitialMigration

Execute o comando abaixo para criar a base de dados:

dotnet ef database update

Manipulando dados do banco de dados

Agora que o acesso foi configurado e a nossa base criada, podemos inserir alguns dados no banco:

private static void InsertData()
{
    using(var context = new MyDbContext())
    {

        var album = new Album()
        {
            Nome = "Acústico MTV - Legião Urbana",
            Ano = 1999,
            Email = "contato@legiaourbana.com.br"
        };

        context.Albuns.Add(album);

        context.Musicas.Add(new Musica
        {
            Nome = "Índios",
            Album = album
        });
        context.Musicas.Add(new Musica
        {
            Nome = "Pais e Filhos",
            Album = album
        });

        context.Musicas.Add(new Musica
        {
            Nome = "Eu sei",
            Album = album
        });

        context.SaveChanges();
    }
}

E visualizá-los:

private static void PrintData()
{
    using (var context = new MyDbContext())
    {
        var musicas = context.Musicas.Include(m => m.Album);
        foreach(var musica in musicas)
        {
            var data = new StringBuilder();
            data.AppendLine($"Musica: {musica.Nome}");
            data.AppendLine($"Album: {musica.Album.Nome}");
            Console.WriteLine(data.ToString());
        }
    }
}

Conclusão

Quando o Entity Framework Core foi criado, era complicado utilizá-lo com o MySQL. Na época a única alternativa disponível eram os provedores da DevArt, que são pagos.

Felizmente, conforme a biblioteca foi sendo atualizada, novos provedores foram sendo adicionados, e hoje é possível utilizar o provedor da Pomelo para se conectar ao MySQL.

Mesmo não sendo o provedor oficial (que na criação deste artigo ainda está em beta e apresenta alguns erros), o provedor da Pomelo é muito poderoso e pode ser utilizado em um ambiente de produção sem maiores preocupações.

C# (C Sharp) Básico
Curso de C# (C Sharp) Básico
CONHEÇA O CURSO

Recursos de linha de comando para o Entity Framework Core

É inegável o quão poderoso é o Visual Studio. Ele possui vários recursos que facilitam (e muito) o desenvolvimento. Mas, com o advento do .NET Core, e a possibilidade de criar a aplicação em qualquer plataforma, alguns desses recursos fazem falta em algumas delas.

Um desses recursos é o “Package Manager Console”, que além de permitir adicionar packages NuGet, também permite executar comandos para certos pacotes, como habilitar as migrations do Entity Framework.

Caso deseje desenvolver a sua aplicação em uma plataforma diferente do Windows (ou não queira utilizar o Visual Studio), o “Package Manager Console” deve ser substituído por comandos do .NET CLI, e neste artigo conheceremos os comandos do Entity Framework Core.

Organizando a casa

Os comandos do .NET CLI só estão disponíveis no SDK do .NET Core, então para executar os comandos que apresentarei a seguir, é necessário instalar este SDK no seu computador.

Além disso, os comandos só estão disponíveis para projetos definidos para uma das versões abaixo do .NET:

  • .NET Framework 4.5.1 ou superior (“net451”, “net452”, “net46”, etc.)
  • .NET Core App 1.0 ou superior (“netcoreapp1.0”, “netcoreapp1.1”, etc.)
Desenvolvedor C# Pleno
Formação: Desenvolvedor C# Pleno
A formação Desenvolvedor C# nível Pleno da TreinaWeb tem um enfoque sobre a conectividade entre o .NET Framework e os bancos de dados relacionais através do ADO.NET. Também serão abordados os recursos para desenvolvedores que o Oracle e o MySQL oferecem, como functions, stored procedures e triggers.
CONHEÇA A FORMAÇÃO

Preparando o palco

Com o ambiente organizado, você já poderá criar uma aplicação por linha de comando utilizando o .NET Core:

dotnet new console -o ExemploEntityCore

A aplicação criada com o comando acima, é uma aplicação de console simples. Ao acessar a pasta dela, é possível adicionar um pacote do NuGET pelo terminal:

dotnet add package Microsoft.EntityFrameworkCore.Design

O pacote Microsoft.EntityFrameworkCore.Design é quem adiciona as ferramentas de linha de comando para o Entity Framework Core. Assim, para elas funcionarem, é necessário executar o comando restore:

dotnet restore

Colocando a mão na massa

Adicione uma entidade na aplicação, como a abaixo:

public class Cliente {
    public int Id { get; set; }
    public string Nome { get; set; }
    public int Idade { get; set; }
}

Assim, é possível criar o DBContext com o comando abaixo:

dotnet ef dbcontext scaffold "Data Source=clientes.db" Microsoft.EntityFrameworkCore.SQLite -c "ClientesDbContext"

Ele irá criar a classe ClientesDbContext, que herdará DBContext, além de já configurar a string de conexão "Data Source=clientes.db", para o provider Microsoft.EntityFrameworkCore.SQLite.

Observação: Os pacotes Microsoft.EntityFrameworkCore.SQLite e Microsoft.EntityFrameworkCore.SQLite.Design deve ser adicionados na aplicação.

Se o comando “dotnet-ef” apresentar algum problema, verifique se foi adicionada a referência abaixo. Se não, adicione-a manualmente:

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

Com o DbContext criado, adicione nele a entidade:

public DbSet<Cliente> Clientes { get; set; }

Que será possível adicionar migrations na aplicação:

dotnet ef migrations add CriaBase

Caso não tenha gostado do resultado, e queira desfazer a ação, pode ser utilizado comando:

dotnet ef migrations remove

Ele sempre irá remover a última migration criada.

Com uma migration definida, é possível executá-la com o comando:

dotnet ef database update

Como a nossa migration inicial cria a base de dados, ele pode ser desfeito com o comando abaixo:

dotnet ef database drop

Que exclui a base de dados.

Caso a entidade seja alterada:

public class Cliente {
    public int Id { get; set; }
    public string Nome { get; set; }
    public int Idade { get; set; }
    public char Sexo { get; set; }
}

É possível adicionar uma nova migration:

dotnet ef migrations add AddColumnSexo

E atualizar novamente a base de dados:

dotnet ef database update
Desenvolvedor ASP.NET Full-Stack
Formação: Desenvolvedor ASP.NET Full-Stack
A formação Desenvolvedor ASP.NET Full Stack da TreinaWeb tem como objetivo abordar as duas principais plataformas dentro do ASP.NET: o ASP.NET MVC, para criação de aplicações web seguindo o padrão MVC/MVW; e o ASP.NET WebAPI, para criação de APIs RESTful que sigam os padrões mais atuais da indústria.
CONHEÇA A FORMAÇÃO

Conclusão

Como foi possível notar, o CLI do Entity Core é muito similar ao realizado no “Package Manager Console”. Então, caso você já esteja acostumado a utilizá-lo no Visual Studio, não terá dificuldade para fazer uso dele pelo terminal. Mas em caso de dúvida, você pode informar o parâmetro --help para obter mais informações sobre cada comando.