.NET microservices using C# 12

Trim the Fat: Write Leaner .NET Microservices using C# 12’s Magic ✨ | A Step-by-Step Guide

by

Hey there, fellow coders! 👋 Let’s talk about something we’ve all grumbled about: boilerplate code. You know, those endless lines of setup, configuration, and ceremony that make our microservices feel like overstuffed suitcases. What if I told you C# 12 is here to help us pack lighter? 🎒

.NET microservices using C# 12

In this post, we’ll build a tiny-but-mighty .NET microservice without the bloat (.NET microservices using C# 12), using C# 12’s slick new features. By the end, you’ll see how to slash code volume while keeping your apps robust, scalable, and actually fun to work on. Whether you’re building Azure serverless microservices or optimizing APIs for Kubernetes, this guide will show you how C# 12 lightweight code patterns can transform your workflow. Let’s roll!

Why Less Code = More Joy (And Better Software)

Microservices thrive on simplicity. Less code isn’t just about fewer keystrokes—it’s about building systems that are:

  • 🚀 Faster to deploy (smaller packages = happier CI/CD pipelines).
  • 🔍 Easier to debug (“Where’s the bug? Oh, right—there’s hardly any code!”).
  • 🧩 More maintainable (your future self will high-five you).
  • 💸 Cheaper to scale (especially with Azure serverless microservices where compute costs matter).

With .NET 8 Minimal APIs and C# 12’s new features, we’re not just cutting corners—we’re redesigning the toolbox. Let’s dive into how these updates help you build cloud-native apps that are lean, mean, and ready for anything.

C# 12’s Superpowers for Microservices

C# 12 isn’t just another incremental update. It’s a game-changer for developers tired of boilerplate. Here’s how to wield its power:

1. Primary Constructors: Bye-Bye, Constructor Bloat

Gone are the days of writing 10 lines just to inject a service. Now, declare dependencies and assign them in one shot:

// BEFORE: Traditional constructor  
public class ProductService  
{  
    private readonly ILogger<ProductService> _logger;  
    private readonly IProductRepository _repo;  

    public ProductService(ILogger<ProductService> logger, IProductRepository repo)  
    {  
        _logger = logger;  
        _repo = repo;  
    }  

    public Product GetProduct(int id) => _repo.GetProduct(id);  
}  

// AFTER: C# 12 primary constructor  
public class ProductService(ILogger<ProductService> logger, IProductRepository repo)  
{  
    public Product GetProduct(int id) => repo.GetProduct(id);  
}

What you gain:

  • ✅ 50% fewer lines per class.
  • ✅ No more private readonly noise.
  • ✅ Cleaner integration with .NET 8 Minimal APIs DI containers.

2. Collection Expressions: Cleaner Data, Faster

Tired of new List<Product> { ... }? Say hello to []:

// OLD WAY  
var products = new List<Product>  
{  
    new Product("Widget", 19.99m),  
    new Product("Gadget", 29.99m)  
};  

// C# 12 WAY  
Product[] products = [new("Widget", 19.99m), new("Gadget", 29.99m)];

Why this rocks for microservices:

  • ✅ Seeding test data? Done in half the time.
  • ✅ API responses? Simplified and more readable.
  • ✅ Less typing = fewer errors.

3. Interceptors: The Secret Sauce for Code Generation (Use Sparingly!)

.NET 8’s experimental interceptors let you silently tweak generated code—perfect for trimming auto-generated gunk in Minimal APIs or gRPC services.

// Example: Modifying a Minimal API endpoint’s behavior  
[Interceptor(typeof(LoggingInterceptor))]  
public static void ConfigureEndpoint(IEndpointConventionBuilder endpoint)  
{  
    // Add logging or validation globally  
}

Pro tip: Interceptors are powerful but experimental. Use them for cross-cutting concerns like logging or auth, but avoid overcomplicating your core logic.

Step-by-Step: Building a Tiny Microservice with C# 12

Let’s build a “Product Catalog” service using .NET 8 Minimal APIs and C# 12. We’ll integrate with Azure Cosmos DB and deploy it as a serverless Azure Function—all while keeping the codebase razor-thin.

Step 1: Set Up the Project

dotnet new webapi -minimal -o ProductCatalog  
cd ProductCatalog  
dotnet add package Microsoft.Azure.Cosmos

Step 2: Define the Model

public record Product(string Id, string Name, decimal Price);

Step 3: Configure Azure Cosmos DB

builder.Services.AddCosmosRepository(options =>  
{  
    options.CosmosConnectionString = builder.Configuration["AZURE_COSMOS_CONNECTION_STRING"];  
    options.ContainerId = "products";  
});

Step 4: Build the API Endpoints

var app = builder.Build();  

app.MapGet("/products", async (IRepository<Product> repo) =>  
    (await repo.GetAllAsync()).ToArray());  

app.MapGet("/products/{id}", async (string id, IRepository<Product> repo) =>  
    await repo.GetAsync(id) is Product product  
        ? Results.Ok(product)  
        : Results.NotFound());  

app.MapPost("/products", async (Product product, IRepository<Product> repo) =>  
{  
    await repo.CreateAsync(product);  
    return Results.Created($"/products/{product.Id}", product);  
});  

app.Run();

Total lines of code: Under 50!

Going Serverless: Deploy to Azure Functions

Pair your lean code with Azure Functions for auto-scaling and pay-per-use pricing:

  1. Add the Azure Functions package:
dotnet add package Microsoft.Azure.Functions.Worker

2. Convert your API to a Function:

[Function("GetProducts")]  
public static async Task<HttpResponseData> Run(  
    [HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequestData req,  
    IRepository<Product> repo)  
{  
    var products = await repo.GetAllAsync();  
    return await req.CreateResponseAsync(products);  
}

Why this combo wins:

  • 🚀 Cold starts? Barely noticeable with tiny codebases.
  • 💸 Cost-effective: Only pay when your API is hit.
  • ☁️ Scalable: Azure handles traffic spikes effortlessly.

Best Practices for Lean Microservices

  1. Embrace Minimal APIs: Ditch controllers for endpoint-centric design.
  2. Leverage C# 12’s Syntactic Sugar: Use primary constructors and collection expressions everywhere.
  3. Go Serverless When Possible: Azure Functions or Azure Container Apps maximize cost savings.
  4. Adopt Native AOT Compilation: Shrink deployment size by 80% with .NET 8’s ahead-of-time compilation.

Pitfalls to Avoid

  • ❌ Overusing Interceptors: They’re experimental—stick to proven patterns.
  • ❌ Skipping Tests: Less code ≠ no tests. Use xUnit or NUnit rigorously.
  • ❌ Ignoring Logging: Minimal code still needs observability. Add Application Insights early.

Real-World Impact: A Case Study

A fintech startup reduced their loan approval microservice’s codebase by 60% using C# 12 and Minimal APIs. Result?

  • Deployment time dropped from 8 minutes to 2.
  • Monthly Azure costs fell 42% due to smaller memory footprints.
  • Developer onboarding accelerated—“It’s like reading a recipe, not a novel.”

Your Turn to Code Smarter

Next time you’re wiring up a microservice, ask: “Can C# 12 do this heavy lifting?” Spoiler: It probably can.

Actionable Next Steps:

  1. Migrate one legacy endpoint to Minimal APIs + C# 12.
  2. Experiment with Native AOT for faster cold starts.
  3. Share your before/after code snippets on LinkedIn—tag #CodeWithPriyesh!

FAQs: Your Questions, Answered

Q: Is C# 12 stable for production?
A: Absolutely! It’s fully supported in .NET 8 LTS.

Q: Can I use Minimal APIs with Blazor?
A: Yes! They pair beautifully for full-stack apps.

Q: How do I handle complex validation in Minimal APIs?
A: Use FluentValidation or ASP.NET Core’s built-in validation.

Wrapping Up

We’re not just saving keystrokes—we’re building services that deploy faster, scale easier, and leave room for what actually matters: solving real-world problems.

Got a success story or a burning question? Drop a comment below—let’s geek out together! 🤓

Leave a Comment