DotNet Web API Basics

Web API Basics

Web API

Definition: Web API (Application Programming Interface) is a set of protocols and tools that allows different software applications to communicate with each other over the internet. It enables applications to interact and exchange data in a standardized way, typically using HTTP (Hypertext Transfer Protocol).

Create Web API Project in Visual Studio

To create a Web API project in Visual Studio, follow these steps:

1. Open Visual Studio.
2. Click on "Create a new project" or go to "File" > "New" > "Project."
3. Select the appropriate project template based on the version of Visual Studio you are using (e.g., ASP.NET Core Web Application or ASP.NET Web Application).
4. Choose the project name and location.
5. Select the Web API template (e.g., ASP.NET Core Web API or ASP.NET Web API).
6. Configure any additional settings, such as authentication and target framework.
7. Click on "Create" to create the Web API project.

Test Web API

To test a Web API, you can use tools such as Postman or Swagger. Here's an example using Postman:

1. Open Postman.
2. Create a new request by clicking on the "+" button.
3. Enter the URL of the Web API endpoint you want to test.
4. Select the appropriate HTTP method (e.g., GET, POST, PUT, DELETE).
5. Add any required headers or parameters.
6. Click on "Send" to execute the request.
7. View the response from the Web API, which may include the status code and the returned data.

Web API Controllers

Web API controllers are classes that handle incoming HTTP requests and generate appropriate responses. They contain action methods that are responsible for processing requests and producing the desired output.

Example of a Web API controller in C#:

csharp
[Route("api/[controller]")]
[ApiController]
public class UsersController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        // Retrieve users from a data source
        var users = UserRepository.GetUsers();
        
        return Ok(users);
    }
    
    [HttpPost]
    public IActionResult Post(User user)
    {
        // Save the user to a data source
        UserRepository.SaveUser(user);
        
        return CreatedAtAction(nameof(Get), new { id = user.Id }, user);
    }
    
    // Other action methods for handling PUT, DELETE, etc.
}

In the above example, the UsersController class is a Web API controller that defines two action methods: Get and Post. The HttpGet attribute specifies that the Get method should handle HTTP GET requests, while the HttpPost attribute indicates that the Post method should handle HTTP POST requests. The methods return appropriate HTTP responses using the IActionResult interface.

Configure Web API

To configure a Web API project, you can make changes to the project's startup class, usually named Startup.cs. Some common configuration tasks include:

1. Adding services: Use the ConfigureServices method to register dependencies and configure services such as database contexts, authentication, and authorization.

csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    // Add other services
}

2. Configuring middleware: Use the Configure method to add middleware components to the request processing pipeline. Middleware components can perform tasks like routing, error handling, and request/response formatting.

csharp
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

Routing in ASP.NET Web API

Routing in ASP.NET Web API determines how incoming HTTP requests are mapped to the appropriate controller and action method. It defines the URL patterns that the API supports.

Example of configuring routing in ASP.NET Web API:

csharp
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Other middleware configuration

    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller}/{action}/{id?}",
            defaults: new { controller = "Home", action = "Index" }
        );
    });
}

In the above example, the MapControllerRoute method is used to configure a default route that matches URLs with the pattern {controller}/{action}/{id?}. It specifies that if no specific controller, action, or ID is provided in the URL, the request should be routed to the Index action method of the HomeController.

Parameter Binding in ASP.NET Web API

Parameter binding in ASP.NET Web API allows you to extract values from the request and bind them to action method parameters. It enables you to receive data from the request in a structured format.

Example of parameter binding in Web API:

csharp
[HttpPost]
public IActionResult Post([FromBody] User user)
{
    // Process the user object received from the request body
    UserRepository.SaveUser(user);
    
    return CreatedAtAction(nameof(Get), new { id = user.Id }, user);
}

In the above example, the FromBody attribute is used to bind the User object from the request body to the user parameter of the Post action method. It allows the method to access the user data sent in the request payload.

Return Types of Web API Action Method

The return type of a Web API action method determines the format and content of the HTTP response generated by the method. Common return types include IActionResult, HttpResponseMessage, and specific data types like string, int, or custom models.

Example of returning different types from a Web API action method:

csharp
[HttpGet("{id}")]
public IActionResult Get(int id)
{
    var user = UserRepository.GetUser(id);
    
    if (user == null)
    {
        return NotFound();
    }
    
    return Ok(user);
}

[HttpPost]
public IActionResult Post(User user)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }
    
    UserRepository.SaveUser(user);
    
    return CreatedAtAction(nameof(Get), new { id = user.Id }, user);
}

In the above examples, the Get action method returns an IActionResult with NotFound or Ok depending on the user's existence. The Post action method returns different types of IActionResult based on the request's validity, using BadRequest or CreatedAtAction to indicate success.

Request, Response Formats in ASP.NET Web API

Request and response formats in ASP.NET Web API define how data is serialized and deserialized when communicating with the API. Common formats include JSON (JavaScript Object Notation) and XML (eXtensible Markup Language).

To configure the request and response formats, you can use the AddMvc or AddControllers method in the ConfigureServices method of the Startup class.

Example of configuring request and response formats for JSON:

csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers()
        .AddJsonOptions(options =>
        {
            options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
            options.JsonSerializerOptions.IgnoreNullValues = true;
        });
}

In the above example, the AddJsonOptions method is used to configure the JSON serialization options. It sets the property naming policy to camel case and ignores null values during serialization.

Media Type Formatters in ASP.NET Web API

Media type formatters in ASP.NET Web API handle the serialization and deserialization of data between the API and clients. They determine how the API formats the response based on the requested media type, such as JSON or XML.

By default, Web API uses the JsonMediaTypeFormatter for JSON serialization and the XmlMediaTypeFormatter for XML serialization. Additional media type formatters can be added or configured as needed.

Example of adding a custom media type formatter for CSV (Comma-Separated Values):

csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers()
        .AddMvcOptions(options =>
        {
            options.OutputFormatters.Add(new CsvMediaTypeFormatter());
        });
}

In the above example, the AddMvcOptions method is used to add a custom CsvMediaTypeFormatter to the list of output formatters. This allows the Web API to handle CSV serialization and produce CSV responses when requested.

Web API Filters

Web API filters are attributes or classes that can be applied to controllers or action methods to perform additional processing before or after the execution of the action.

There are several types of filters available in ASP.NET Web API, including:

• Authorization filters: Validate the request's authorization and permissions.
• Action filters: Perform logic before and after the execution of an action method.
• Exception filters: Handle exceptions thrown during the execution of an action.
• Result filters: Modify the result of an action before it's returned to the client.

Example of applying an authorization filter to a Web API controller:

csharp
[Authorize]
public class UsersController : ControllerBase
{
    // Controller code
}

In the above example, the [Authorize] attribute is applied to the UsersController class, which ensures that only authenticated users can access the controller's actions.

Configure Dependency Injection in ASP.NET Web API

Dependency injection (DI) in ASP.NET Web API allows you to manage and resolve dependencies required by your application's components. It promotes loose coupling and improves testability and maintainability.

To configure dependency injection in ASP.NET Web API, you can use the built-in dependency injection container or third-party containers like Autofac or Ninject.

Example of configuring dependency injection in ASP.NET Web API:

csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddScoped<IUserService, UserService>();
    // Register other dependencies
}

In the above example, the AddScoped method is used to register the IUserService interface with the UserService implementation as a scoped dependency. This allows the Web API to resolve and inject the IUserService implementation whenever it's required.

Web API Hosting

Web API hosting refers to the process of deploying and running a Web API application on a server or hosting platform so that it can be accessed by clients over the internet.

There are various hosting options available for ASP.NET Web API, including:

• Self-hosting: Hosting the Web API within a custom application or service.
• Internet Information Services (IIS): Deploying the Web API to an IIS web server.
• Azure App Service: Hosting the Web API on the Azure cloud platform.
• Docker containers: Packaging the Web API application into a container for easy deployment and scalability.

The hosting option chosen depends on factors such as scalability requirements, deployment preferences, and infrastructure capabilities.

ASP.NET Web API Learning Resources

Here are some learning resources to further explore ASP.NET Web API:

1. Microsoft Docs: ASP.NET Web API
2. Pluralsight: Building a RESTful API with ASP.NET Core
3. Udemy: Complete ASP.NET Web API Course
4. YouTube: ASP.NET Web API Tutorial for Beginners
5. GitHub: ASP.NET Web API Samples

These resources provide in-depth tutorials, videos, and sample code to help you learn and master ASP.NET Web API development.