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 an in-memory database using Entity Framework and ASP.NET Core 2.0 without any theoretical explanation. To know more about concepts and theory, my previous articles can be referred to.

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, 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 the workshops by adding the below code,

[HttpGet]
 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 the CRUD operations. Let’s go ahead and add these.

[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 the 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.