Asp.Net Web Api Setting Up Development Environment In Visual Studio Complete Guide

Prerequisites

• Visual Studio: You should have Visual Studio installed on your computer. You can download the free Community Edition from the Visual Studio website.
• .NET SDK: Visual Studio generally comes with the .NET SDK, but make sure it is installed by checking the version in the command line:

  dotnet --version
  

Step-by-Step Guide

Step 1: Install Visual Studio

1. Download Visual Studio Community Edition or the edition of your choice from the Visual Studio website.
2. Run the downloaded installer and follow the prompts.
3. During the installation, you can select the workloads you want to install. For ASP.NET Web API development, ensure the following workload is selected:
   • ASP.NET and web development
4. Install the necessary components (e.g., .NET desktop development, .NET Core cross-platform development).

Step 2: Create a New ASP.NET Web API Project

1. Start Visual Studio.

2. On the Start Window, click on Create a new project.

3. In the Create a new project window:

   • In the search bar, type Web API.
   • From the list of templates, select ASP.NET Core Web API and click Next.

   

4. Configure your new project:

   • Project name: Enter MyFirstWebApi.
   • Location: Choose the location where you want the project files to be stored.
   • Solution name: Optionally, give a name to the solution.
   • Click Create.

   

5. In the next window, configure your API project:

   • Ensure that the Framework is set to your preferred (.NET 6.0 or later recommended).
   • Uncheck Use controllers (uncheck to use minimal APIs) if you prefer using the older MVC-style controllers.
   • Check Enable Docker Support if you want to use Docker (optional).
   • Leave the other options as default.
   • Click Create.

   

Step 3: Explore the Generated Project

Upon creation, the project will contain several default files and folders:

• Controllers: Contains the API controllers.
• Program.cs: Entry point for the application.
• appsettings.json: Configuration file.

Step 4: Add a Simple Controller

If you unchecked Use controllers (uncheck to use minimal APIs) during project configuration, you can add a controller manually.

1. Add a Controller Class:

   • In Solution Explorer, right-click on the Controllers folder, then select Add > Controller.
   • Choose API Controller with read/write actions.
   • Name your controller ItemsController (make sure the filename ends with Controller.cs).
   • Click Add.

2. Modify the Controller:

   • A class named ItemsController will be generated with some sample actions. Let's modify it slightly.

   using Microsoft.AspNetCore.Mvc;
   
   namespace MyFirstWebApi.Controllers {
       [ApiController]
       [Route("[controller]")]
       public class ItemsController : ControllerBase {
           private static readonly List<string> _items = new List<string>{"Item1", "Item2"};
   
           [HttpGet]
           public ActionResult<IEnumerable<string>> Get() {
               return _items;
           }
   
           [HttpGet("{id}")]
           public ActionResult<string> Get(int id) {
               if (id >= _items.Count || id < 0) {
                   return NotFound();
               }
               return _items[id];
           }
   
           [HttpPost]
           public IActionResult Post([FromBody] string item) {
               _items.Add(item);
               return CreatedAtAction(nameof(Get), new { id = _items.Count - 1 }, item);
           }
   
           [HttpPut("{id}")]
           public IActionResult Put(int id, [FromBody] string item) {
               if (id >= _items.Count || id < 0) {
                   return NotFound();
               }
               _items[id] = item;
               return NoContent();
           }
   
           [HttpDelete("{id}")]
           public IActionResult Delete(int id) {
               if (id >= _items.Count || id < 0) {
                   return NotFound();
               }
               _items.RemoveAt(id);
               return NoContent();
           }
       }
   }
   

Step 5: Use Minimal APIs Instead

Minimal APIs allow you to create an API with less boilerplate code. Follow these steps to configure the project with minimal APIs:

1. Open Program.cs.

2. Modify the file to define a minimal API:

   var builder = WebApplication.CreateBuilder(args);
   
   // Add services to the container.
   // builder.Services.AddControllers();
   
   var app = builder.Build();
   
   // Configure the HTTP request pipeline.
   if (app.Environment.IsDevelopment()) {
       app.UseDeveloperExceptionPage();
   }
   
   app.UseHttpsRedirection();
   
   // Sample in-memory items list
   var items = new List<string>{"Item1", "Item2"};
   
   // Define endpoints
   app.MapGet("/items", () => items);
   app.MapGet("/items/{id}", (int id) => 
       id >= items.Count || id < 0 ? Results.NotFound() : Results.Ok(items[id]));
   app.MapPost("/items", ([FromBody] string item) => {
       items.Add(item);
       return Results.Created($"/items/{items.Count - 1}", item);
   });
   app.MapPut("/items/{id}", (int id, [FromBody] string item) => {
       if (id >= items.Count || id < 0) {
           return Results.NotFound();
       }
       items[id] = item;
       return Results.NoContent();
   });
   app.MapDelete("/items/{id}", (int id) => {
       if (id >= items.Count || id < 0) {
           return Results.NotFound();
       }
       items.RemoveAt(id);
       return Results.NoContent();
   });
   
   app.Run();
   

Step 6: Run the Project

1. Run the Application:
   • Press F5 or click the green play button in Visual Studio to run your web application.
2. View the Swagger UI (if not using minimal APIs):
   • If you used the default project template with controllers enabled, Visual Studio should automatically launch the Swagger UI for testing your API.
3. Test Minimal APIs Endpoints:
   • You can test the endpoints manually using a browser or tools like Postman or curl.

Step 7: Test Your API Endpoints

You can use different tools to test your API endpoints.

• Swagger UI: For projects with controllers, Visual Studio automatically generates Swagger documentation.

• Postman: Download and install Postman to send HTTP requests and test your API endpoints.

• curl: Use the command line with curl to interact with your API. Example: