Entity Framework Core com MySQL

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

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.

Deixe seu comentário

Instrutor, nerd, cinéfilo e desenvolvedor nas horas vagas. Graduado em Ciências da Computação pela Universidade Metodista de São Paulo.

JUNTE-SE A MAIS DE 150.000 PROGRAMADORES