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.

Thursday, August 2, 2018

Using DotNet Watcher with ASP.NET Core 2.0 Application

This is a feature which can be used on the command line to watch our web application. Whenever a C# class is modified and saved, it automatically re-compiles and re-runs whatever command we pass into it. In other words, as soon as C# code is modified and saved, the watcher will see those changes and re-compiles the code without a need to close the running application.

Let’s have a look on how it works.

Step 1:
Open any existing ASP.NET Core 2.0 project and open it’s project file by right clicking on project and clicking on ‘Edit XXX.csproj ‘ and add one more line as highlighted below:

<ItemGroup>
    <DotNetCliToolReference Include="Microsoft.DotNet.Watcher.Tools" Version="2.0.2" />
    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.2" />
    <DotNetCliToolReference Include="Microsoft.Extensions.SecretManager.Tools" Version="2.0.1" />
    <DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.3" />
</ItemGroup>

Step 2: Open command prompt and navigate to the project path. Type command as shown in below screenshot:












In above screenshot, I’m using run command as I want to re-run my application whenever code changes are there. If everything went well, then you will see the last line with a statement as ‘Application started. Press Ctrl+C to shut down.’ with an information about listening port.

Step 3: Copy the listening port URL and paste it on the browser as shown below:






You will notice that site is up and running along with much more information displayed on the command line window.

Step 4: Next is to navigate to any page in your application where you are going to modify any C# code. For me, I’m going to take About page. Initially my page is as below:










Now I’ll go to my AboutModel.cs and change message text. Quickly save the application and switch to command line window. You will notice that a red color text is displayed and application is automatically restarted. Here is the snapshot of command line:














Go to the browser and refresh the page, you will see that without closing the entire application you are able to see the updated text as shown below:









To know more about the released versions of Watcher tool, refer an official link. 

Hope you enjoyed leaning this tool.