.NET  

Mastering .NET Interviews – Part 7: Web API & Microservices

📌 Series Context: This is the seventh article in the 10‑part series covering the most important areas of .NET interview preparation. In Part 1, we introduced the .NET ecosystem. In Part 2, we covered C# fundamentals. In Part 3, we explored advanced C# features. In Part 4, we discussed ASP.NET MVC. In Part 5, we focused on ASP.NET Core. In Part 6, we covered Entity Framework & Data Access. Now, we'll explore Web API & Microservices.

Why Web API & Microservices?

Modern applications rely on APIs to expose functionality and integrate with other systems. ASP.NET Core Web API is widely used to build RESTful services. Microservices architecture takes this further by breaking applications into independent, loosely coupled services.

Interviewers often ask about REST principles, API versioning, authentication, and microservices design patterns.

REST Principles

Stateless

  • Each request contains all necessary information.

Resource-Based

  • Everything is treated as a resource (patients, invoices, staff).

HTTP Methods

  • GET

  • POST

  • PUT

  • DELETE

Uniform Interface

  • Consistent resource representation.

Example: Patient Web API

Controller

[ApiController]
[Route("api/[controller]")]
public class PatientController : ControllerBase
{
    private readonly IPatientService _service;

    public PatientController(IPatientService service)
    {
        _service = service;
    }

    [HttpGet]
    public IActionResult GetAll()
    {
        return Ok(_service.GetAll());
    }

    [HttpPost]
    public IActionResult Create(Patient patient)
    {
        _service.Add(patient);
        return CreatedAtAction(nameof(GetAll), patient);
    }
}

👉 Interview Tip: Be ready to explain the difference between Controller and ControllerBase.

API Versioning

Versioning ensures backward compatibility.

services.AddApiVersioning(options =>
{
    options.DefaultApiVersion = new ApiVersion(1, 0);
    options.AssumeDefaultVersionWhenUnspecified = true;
    options.ReportApiVersions = true;
});

👉 Common Versioning Strategies:

  • URL Versioning

  • Query String Versioning

  • Header Versioning

Authentication & Security

JWT (JSON Web Tokens)

  • Commonly used for securing APIs.

OAuth2

  • Industry standard for authorization.

API Keys

  • Simple but less secure than JWT and OAuth2.

Example JWT Authentication Configuration

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters =
            new TokenValidationParameters
            {
                ValidateIssuer = true,
                ValidateAudience = true,
                ValidateLifetime = true,
                ValidateIssuerSigningKey = true
            };
    });

Microservices Architecture

Microservices break applications into independent services that communicate through APIs or messaging systems.

Key Principles

  • Loose Coupling

  • Independent Deployment

  • Scalability

  • Resilience

Common Tools

  • Docker

  • Kubernetes

  • Azure Service Bus

  • RabbitMQ

Common Interview Questions (Part 7)

  • What are the REST principles?

  • How do you implement API versioning in ASP.NET Core?

  • Explain JWT authentication.

  • What is the difference between monolithic and microservices architecture?

  • How do microservices communicate with each other?

  • What are the challenges of microservices deployment?

Conclusion

In this seventh part, we covered:

  • REST principles and HTTP methods.

  • Example Web API controller for patient management.

  • API versioning strategies.

  • Authentication and security with JWT and OAuth2.

  • Microservices architecture principles and tools.

This foundation prepares you for Part 8, where we'll explore Azure & Cloud Integration—covering hosting, serverless functions, and cloud databases.

Summary

ASP.NET Core Web APIs enable applications to expose functionality through RESTful services, while microservices architecture helps organizations build scalable and independently deployable systems. Understanding REST principles, API versioning, JWT authentication, OAuth2, and microservices design patterns is essential for modern .NET development and frequently appears in technical interviews.

Membership not found