Crear una conexion MySQL + NetCore (Ejemplo CRUD)

En esta entrada aprenderemos a crear una conexión entre MySQL y NetCore utilizando EntityFramework. 

Primer paso, abrimos una consola de comandos [ en mi caso CMD / Windows 10 ] y crearemos la estructura de la aplicación utilizando Yeoman 

En el interprete de comando escribimos la siguiente instrucción: 

yo aspnet 

Como nombre le pondré mysqltest para hacer referencia a que estaremos trabajando en hacer una prueba de conexión a MySQL 

Abrimos el folder de la aplicación con Visual Studio Code 

Buscamos el archivo Project.json y agregaremos las siguientes líneas de código: 

En el apartado Dependencias (Dependencies): 

"Microsoft.EntityFrameworkCore.InMemory": "1.0.1",    "Microsoft.EntityFrameworkCore": "1.0.1",    "MySql.Data.EntityFrameworkCore": "7.0.6-IR31",    "Microsoft.EntityFrameworkCore.Tools": { 

     "version": "1.0.0-preview2-final", 

     "type": "build"

    }

En el apartado tools agregaremos las siguientes líneas:

"Microsoft.EntityFrameworkCore.Tools": {
      "version": "1.0.0-preview2-final",
      "imports": [
        "portable-net45+win8+dnxcore50",
        "portable-net45+win8"
      ]
    } 

Después de realizar esta modificación, VSC nos preguntará que si deseamos restaurar las dependencias, eliges la opción Restore y esperamos a que las dependencias sean restauradas. El tiempo de restauración dependerá en gran medida de tu conexión a Internet.

Ahora abrimos el archivo appsettings.json y agregamos la siguiente cadena de conexión:

,

  "ConnectionStrings": {
    "DefaultConnection": "server=localhost;userid=tuusuario;pwd=tupassword;port=3306;database=mysqltest;sslmode=none;"
  },
  "Data": {
    "AuroraConnection": {
      "InMemoryProvider": false
    }
  }

Donde los apartados tuusuario y tupassword equivalen a tu usuario y contraseña local.

Ahora, procederemos a crear una carpeta con el nombre Entities y otra con el nombre Infraestructura.

Creamos una nueva entidad de nombre Persona dentro de la carpeta Entities

namespace mysqltest.Entities
{
    public class Persona {
        public int Id {get;set;}
        public string Nombre {get;set;}
        public string Telefon {get;set;}
        public string Direccion {get;set;}
    }
}

Ahora, dentro de la carpeta Infraestructure crearé una clase llamada MySqlContexto.cs que contendrá el contexto de la aplicación.

using Microsoft.EntityFrameworkCore;
using mysqltest.Entities;
namespace mysqltest.Infraestructura
{
    public class MySqlContexto: DbContext
    {
        public MySqlContexto(DbContextOptions<MySqlContexto> options )
        :base (options){}
        //Databaseset
        public DbSet<Persona> Personas {get;set;}
    }
} 

Ahora nos dirigimos al archivo Startup.cs y agregamos la siguiente línea de código


        public void ConfigureServices(IServiceCollection services)
        {
             string sqlConnectionString = Configuration["ConnectionStrings:DefaultConnection"];
            bool useInMemoryProvider = bool.Parse(Configuration["Data:AuroraConnection:InMemoryProvider"]);

            // Add framework services.
            services.AddDbContext<MySqlContexto>(options =>
            {
                switch (useInMemoryProvider)
                {
                    case true:
                        options.UseInMemoryDatabase();
                        break;
                    default:
                        options.UseMySQL(sqlConnectionString);
                        break;
                }
            });
            // Add framework services.
            services.AddMvc();
        }

Ahora abrimos el Terminal CTRL + ñ y ejecutaremos las siguientes instrucciones:

dotnet ef migrations add inicial

ahora ejecuta

dotnet ef database update

Este ultimo comando nos creará la estructura de la base de datos a partir de la entidad

Ahora le daremos funcionalidad a la aplicación, vamos a crear un controlador llamado PersonasController dentro de la carpeta Controller

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using mysqltest.Entities;
using mysqltest.Infraestructura;
namespace mysqltest.Controllers
{
    public class PersonasController : Controller
    {
        private readonly MySqlContexto _contexto;
        public PersonasController(MySqlContexto contexto)
        {
            _contexto = contexto;
        }
        //Retorna la información contenida en la base de datos
        public async Task<IActionResult> Index(){
            return View(await _contexto.Personas.ToListAsync());
        }
        //Detalles de la persona
        public async Task<IActionResult> Detalles(int id){
            if(id==null)
            {
                return NotFound();
            }
            var persona = await _contexto.Personas.SingleAsync(p=>p.Id == id);
            if(persona==null)
            {
                return NotFound();
            }
            return View(persona);
        }
      public IActionResult Create()
      {
          return View();
      }
      [HttpPost]
      [ValidateAntiForgeryTokenAttribute]
        public async Task<IActionResult> Create (Persona p)
        {
            if(ModelState.IsValid)
            {
                _contexto.Personas.Add(p);
                await _contexto.SaveChangesAsync();
                return RedirectToAction("Index");
            }
            return View(p);
        }
        public  async Task<IActionResult> Editar(int Id)
      {
          if(Id == null)
          {
              return NotFound();
          }
          var p = await _contexto.Personas.SingleOrDefaultAsync(per => per.Id== Id);
          if(p== null)
          {
              return NotFound();
          }
          return View(p);
      }
      [HttpPost]
      [ValidateAntiForgeryTokenAttribute]
        public async Task<IActionResult> Editar (Persona p)
        {
         
          if(p.Id == 0)
          {
              return NotFound();
          }
          if(ModelState.IsValid){
              try{
                  _contexto.Update(p);
                  await _contexto.SaveChangesAsync();
              }catch(DbUpdateConcurrencyException)
              {
                  return RedirectToAction("Index");
              }
                  return RedirectToAction("Index");
          }
            return View(p);
        }
        public async Task<IActionResult> Borrar(int id)
        {
            if(id==null)
            {
                return NotFound();
            }
            var persona = await _contexto.Personas.SingleOrDefaultAsync(per => per.Id == id);
            if(persona == null)
            {
                return NotFound();
            }
            return View(persona);
        }
        [HttpPost, ActionName("Borrar")]
        [ValidateAntiForgeryTokenAttribute]
        public async Task<IActionResult> DeleteConfirmed(int id)
        {
            var p = await _contexto.Personas.SingleOrDefaultAsync(per => per.Id == id);
            _contexto.Personas.Remove(p);
            await _contexto.SaveChangesAsync();
            return RedirectToAction("Index");  
        }
    }
}

Dentro de la carpeta Views crearemos un nuevo folder al que le pondremos por nombre Personas, dentro de la carpeta Personas creamos los siguiente archivos:

Index.cshtml,

@model IEnumerable<mysqltest.Entities.Persona>
@{
    ViewData["Title"] = "Inicio Personas";
}
<h2>Index</h2>
<p>
    <a asp-action="Create">Nuevo Registro</a>
</p>
<table class="table">
        <thead>
            <tr>
                <th>Nombre</th>
                <th>Dirección</th>
                <th>Teléfono</th>
                <th></th>
                </tr>
        </thead>
        <tbody>
            @foreach(var item in Model)
            {
                <tr>
                    <td>@Html.DisplayFor(modelItem=> item.Nombre)</td>
                    <td>@Html.DisplayFor(modelItem=> item.Direccion)</td>
                    <td>@Html.DisplayFor(modelItem=> item.Telefon)</td>
                    <td> <a asp-action="Editar" asp-route-id="@item.Id"> Editar</a> |<a asp-action="Borrar" asp-route-id="@item.Id"> Borrar</a></td>
                 </tr>
            }
        </tbody>
</table>

Create.cshtml,

@model mysqltest.Entities.Persona
@{
    ViewData["Title"] = "Crear un nuveo registro de Personas";
}
<h2>Nuevo registro</h2>
 @using (Html.BeginForm())
        {
           
                    @Html.AntiForgeryToken()
                    @Html.ValidationSummary(true)
                    <div class="form-horizontal">
                        <label class="col-sm-2 control-label">Nombre:</label>
                        <div class="col-sm-4">
                            @Html.TextBoxFor(model=>model.Nombre)
                        </div>
                    </div>
                    <div class="form-horizontal">
                        <label class="col-sm-2 control-label">Direccion</label>
                        <div class="col-sm-4">
                            @Html.TextAreaFor(model =>model.Direccion)
                        </div>
                    </div>
                    <div class="form-horizontal">
                        <label class="col-sm-2 control-label">Telefono</label>
                        <div class="col-sm-4">
                            @Html.TextBoxFor(model=>model.Telefon)
                        </div>
                    </div>
                   
                        <button type="submit" class="btn btn-success btn-rounded">Guardar</button>
        }

Borrar.cshtml

@model mysqltest.Entities.Persona
@{
    ViewData["Title"] = "Eliminar registro de Personas";
}
<div class="alert alert-danger fade in">
    <h4>Aurora confirmaciones</h4>
    <p>¿Estás completamente que quieres eliminar el siguiente elemento: @Html.DisplayFor(model => model.Nombre) del sistema? </p>
    <p>
        @using (Html.BeginForm())
        {
            @Html.AntiForgeryToken()
            <div class="form-actions no-color">
                <div class="btn-group-list pull-right">
                    <input type="submit" value="Eliminar" class="btn btn-rounded btn-danger " />
                </div>
            </div>
        }
    </p>
</div>

Descarga el código fuente desde mi repositorio Git Hub Descargar