Wednesday, August 15, 2018

CRUD operations using ASP.NET Core 2.0 and In-memory database with Entity Framework

In this article, we will create a Web API with in-memory database using Entity Framework and ASP.NET Core 2.0 without any theoretical explanation. To know more on concepts and theory, my previous articles can be referred.

Let’s quickly create a new ASP.NET Core application by choosing API template and name it as ConferencePlanner. Add a new Model entity named Workshop inside a newly add Models folder as shown below:
public class Workshop
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Speaker { get; set; }
}
Here we are going to use in-memory class along with EF. So, we have to add a new class for setting up the database context as shown below:
public class ApplicationDbContext:DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> context):base(context)
    {
    }
}
Now we have to maintain multiple workshops under a conference. So, go ahead and add a DBSet in ApplicationContext class:
       
public DbSet<Workshop> Workshops { get; set; }       
 
Next is to register the DBContext with our application. So, add the below code in Startup.cs class:
public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
   services.AddDbContext<ApplicationDbContext>(context => { context.UseInMemoryDatabase("ConferencePlanner"); });
}
Now we will add an Empty Controller using scaffolding options and name it as WorkshopController. Here we also have to associate database context with this controller. So, let’s associate the database context as shown below with some dummy data in it.
public class WorkshopController : Controller 
{
    private ApplicationDbContext _context; 
    public WorkshopController(ApplicationDbContext context)
    {
      _context = context;
       if (!_context.Workshops.Any()) 
       {
         _context.Workshops.Add(new Workshop 
                  { Name = "Event Management", Speaker = "Shweta"});
         _context.SaveChanges(); 
       }
    }
}
Let's add our first method to get a list of all workshops by adding below code:
[HttpPost]
public IEnumerable<Workshop> GetWorkshops(){return _context.Workshops; } 
Now before proceeding further, let’s quickly build the application and run it. Verify that it is working fine as expected.

[{"id":1,"name":"Event Management","speaker":"Shweta"}]

Now our base setup is ready. We can add add the CRUD operations. Let’ go ahead and add those.
[HttpPost]
public IActionResult AddWorkshop(Workshop workshop)
{
       if (workshop == null)
            return BadRequest();
       _context.Workshops.Add(workshop);
       _context.SaveChanges();
       return CreatedAtRoute("GetWorkshops", new { id = workshop.Id }, workshop);
}
In above code snippet, CreateAtRoute() method is associating newly added workshop object to exiting list of workshops. So, that it can be read by method GetWorkshops().
[HttpPut("{id}")] // means that this id will come from route
public IActionResult UpdateWorkshopByID(int id, [FromBody]Workshop ws)
{
    if (ws == null || ws.Id != id)
          return BadRequest();
    var workshop = _context.Workshops.FirstOrDefault(i => i.Id == id);
   if (workshop == null)
          return NotFound();
    workshop.Name = ws.Name;
    workshop.Speaker = ws.Speaker;
    _context.Workshops.Update(workshop);
    _context.SaveChanges();
    return new NoContentResult();
}
[HttpDelete]
public IActionResult DeleteWorkshopByID(int id)
{
    var workshop = _context.Workshops.FirstOrDefault(i => i.Id == id);
    if (workshop == null)
         return NotFound();
    _context.Workshops.Remove(workshop);
    _context.SaveChanges();
    return new NoContentResult();
}
Hope you enjoyed learning CRUD operations.

No comments:

Post a Comment