DEV Community: Seigo Kitamura

Part 3 - Production-Ready C#: Resource Management, Testing & Telemetry, Security & Reliability

Seigo Kitamura — Wed, 07 Jan 2026 11:03:48 +0000

Excerpt

This post focuses on the practices that keep C# services healthy in production: proper disposal (IDisposable/IAsyncDisposable), timeouts and cancellation, tests/benchmarks/diagnostics, structured logging with tracing, and security/reliability measures (validation, injection prevention, idempotency).

Production-Ready Practices

Resource Management: IDisposable, IAsyncDisposable, Timeouts/Cancellation
Testing, Diagnostics (BenchmarkDotNet, Analyzers), Logging, OpenTelemetry
Security & Reliability (Validation, Injection Prevention, Idempotency)

Resource Management: IDisposable, IAsyncDisposable, Timeouts/Cancellation

Why it matters:
Proper resource management prevents leaks, improves reliability, and ensures predictable cleanup.

Scope-based disposal (diagram):

Acquire resource --> Using scope --> Work with resource --> Scope ends --> Dispose deterministically

Deterministic disposal

using var stream = File.OpenRead(path); // dispose at scope end
await using var connection = new SomeAsyncDisposable(); // IAsyncDisposable for async cleanup

Timeouts + cancellation

public async Task<string> FetchAsync(HttpClient http, string url, CancellationToken ct) {
    using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
    cts.CancelAfter(TimeSpan.FromSeconds(3));
    return await http.GetStringAsync(url, cts.Token).ConfigureAwait(false);
}

Guidelines

Do not rely on finalizers; they’re non-deterministic.
Dispose streams, DB connections, sockets promptly.
Propagate CancellationToken from controller → service → repository.

Testing, Diagnostics (BenchmarkDotNet, Analyzers), Logging, OpenTelemetry

Why it matters:
Testing and diagnostics ensure correctness and performance. Logging and tracing provide observability and help diagnose issues in production.

Unit & integration tests

// xUnit unit test
public class MathTests {
    [Fact]
    public void Sum_Works() => Assert.Equal(7, 3 + 4);
}

// ASP.NET Core integration test with WebApplicationFactory
public class ApiTests : IClassFixture<WebApplicationFactory<Program>> {
    private readonly HttpClient _client;
    public ApiTests(WebApplicationFactory<Program> factory) => _client = factory.CreateClient();

    [Fact]
    public async Task GetUsers_ReturnsOk() {
        var res = await _client.GetAsync("/api/users");
        Assert.True(res.IsSuccessStatusCode);
    }
}

Benchmarking (evidence-based decisions)

[MemoryDiagnoser]
public class ConcatBench {
    [Benchmark]
    public string PlusConcat() {
        var s = "";
        for (int i = 0; i < 1000; i++) s += i;
        return s;
    }

    [Benchmark]
    public string StringBuilderConcat() {
        var sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) sb.Append(i);
        return sb.ToString();
    }
}

Static analysis & null-safety

Enable nullable reference types: #nullable enable
Use Roslyn analyzers, StyleCop/FxCop rules to catch maintainability issues.

Structured logging & correlation

public class UsersController : ControllerBase {
    private readonly ILogger<UsersController> _logger;
    public UsersController(ILogger<UsersController> logger) => _logger = logger;

    [HttpGet]
    public IActionResult Get() {
        using (_logger.BeginScope(new Dictionary<string, object> { ["CorrelationId"] = Guid.NewGuid() })) {
            _logger.LogInformation("Fetching users");
            return Ok(new[] { "alice", "bob" });
        }
    }
}

Tracing with OpenTelemetry (high-level)

// Program.cs
builder.Services.AddOpenTelemetry()
    .WithTracing(t => t
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddSource("MyCompany.MyService"))
    .StartWithHost();

// Use ActivitySource in code
var activitySource = new ActivitySource("MyCompany.MyService");
using var activity = activitySource.StartActivity("ProcessOrder");
// add tags/events...

Observability pipeline (diagram):

App code --> ILogger<T> --> Log sink --> Central log store
        \-> ActivitySource -> OTel exporter -> Tracing backend

Security & Reliability (Validation, Injection Prevention, Idempotency)

Why it matters:
Security and reliability are critical for protecting data, preventing attacks, and ensuring robust service behavior.

Validation

public class CreateUserRequest {
    [Required, EmailAddress] public string Email { get; set; } = default!;
    [Required, MinLength(8)] public string Password { get; set; } = default!;
}

Prevent injection

SQL parameterization (ORMs handle this; use FromSqlInterpolated carefully).
Encode/escape output in HTML contexts.

Idempotency & retries

Make external calls idempotent; use idempotency keys or PUT semantics where possible.
Use timeouts and circuit-breakers for resiliency; apply retries where safe.

Timeout + retry sketch

public async Task<string> SafeFetchAsync(HttpClient http, string url, CancellationToken ct) {
    using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
    cts.CancelAfter(TimeSpan.FromSeconds(2));
    for (int attempt = 0; attempt < 3; attempt++) {
        try {
            return await http.GetStringAsync(url, cts.Token);
        } catch (TaskCanceledException) when (!ct.IsCancellationRequested) {
            // timeout -> retry with backoff
            await Task.Delay(TimeSpan.FromMilliseconds(100 * (attempt + 1)), ct);
        }
    }
    throw new TimeoutException("Exceeded retry attempts");
}

CTA

This wraps up the series. Consider packaging these posts with a downloadable PDF as a single reference for your team or future reference. Share your production lessons learned—what’s your favorite reliability design pattern?

Series Navigation

Part 1 - Core Foundations for Enterprise C#

Part 2 - Performance & Concurrency Essentials in C#

Part 2 - Performance & Concurrency Essentials in C#: Memory, Async, and High-Performance Primitives

Seigo Kitamura — Wed, 07 Jan 2026 11:03:37 +0000

Excerpt

This post covers the C# performance essentials for enterprise backends: memory semantics (stack vs heap, value vs reference, GC), async/await with cancellation, streaming via IAsyncEnumerable<T>, concurrency primitives, Span<T>, pooling, and pitfalls with boxing and large structs.

Performance & Concurrency Essentials

Memory Model: Stack vs Heap, Value vs Reference, GC
Async/await & Cancellation, IAsyncEnumerable, Concurrency Primitives
Span, Pooling, Boxing, Large Struct Caveats

Memory Model: Stack vs Heap, Value vs Reference, GC

Why it matters:
Efficient memory management reduces GC pressure and improves performance.

Diagram: Memory at a glance

+---------------------------+           +--------------------------------+
|           Stack           |           |              Heap              |
|---------------------------|           |--------------------------------|
| int x = 42                |           | new User() { Name = "Alice" } |
| Point p (struct inline)   |   --->    |  reference held on the stack  |
| local frames, by-value    |           | objects, arrays, strings      |
+---------------------------+           +--------------------------------+

Essentials

Value types (struct, record struct) are copied by value and often stored inline; cheap for tiny models.
Reference types (class, record) live on the heap; managed by the GC.
Reduce boxing/unboxing (avoid storing struct in object, prefer generics).
Use StringBuilder for heavy concatenation; prefer ArrayPool<T> and Span<T>/Memory<T> for parsing and allocations.

Boxing pitfall

struct Counter { public int Value; }
object o = new Counter { Value = 5 }; // boxing (allocates)
Counter c = (Counter)o;               // unboxing (copy)

ArrayPool & Span for parsing

using System.Buffers;

var pool = ArrayPool<byte>.Shared;
byte[] buffer = pool.Rent(4096);
try {
    var span = new Span<byte>(buffer, 0, 4096);
    // parse span...
}
finally {
    pool.Return(buffer);
}

GC awareness

Allocation spikes can trigger GC; keep hot paths allocation-light.
Prefer struct enumerators and readonly struct for tight loops when practical.

Async/await & Cancellation, IAsyncEnumerable, Concurrency Primitives

Why it matters:
Modern services must scale and stay responsive. Async and concurrency patterns are essential for I/O and CPU-bound workloads.

Guidelines

async/await is for I/O-bound work; for CPU-bound tasks use Task.Run carefully.
Always pass CancellationToken; prefer timeouts and propagate cancellation across layers.
For streaming, use IAsyncEnumerable<T>; avoid buffering large sets in memory.

Cancellation & timeout

public async Task<string> FetchAsync(HttpClient http, string url, CancellationToken ct) {
    using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
    cts.CancelAfter(TimeSpan.FromSeconds(5));
    return await http.GetStringAsync(url, cts.Token).ConfigureAwait(false);
}

Streaming results

public async IAsyncEnumerable<int> GetNumbersAsync([EnumeratorCancellation] CancellationToken ct = default) {
    for (int i = 0; i < 100; i++) {
        ct.ThrowIfCancellationRequested();
        await Task.Delay(10, ct);
        yield return i;
    }
}

Concurrency primitives

// SemaphoreSlim: limit concurrent access
var sem = new SemaphoreSlim(5);
await sem.WaitAsync(ct);
try {
    // critical section
} finally {
    sem.Release();
}

// Channels: producer-consumer without manual locks
var channel = Channel.CreateUnbounded<string>();
_ = Task.Run(async () => {
    await foreach (var item in channel.Reader.ReadAllAsync(ct)) {
        // process item
    }
});
await channel.Writer.WriteAsync("work-item", ct);
channel.Writer.Complete();

Library tip

In libraries, prefer ConfigureAwait(false) to avoid deadlocks in legacy sync contexts.

Span, Pooling, Boxing, Large Struct Caveats

Span notes

Span<T> is a stack-only ref struct for high-performance slicing—no heap allocations.
Cannot cross await or be captured in lambdas; use Memory<T>/ReadOnlyMemory<T> for async boundaries.

ReadOnlySpan<char> span = "1234".AsSpan();
int total = 0;
foreach (var ch in span) total += (ch - '0');

Large struct caveats

Large structs incur copy cost when passed/returned; prefer classes or use in parameters for read-only refs.

public readonly struct BigValue {
    public readonly int A, B, C, D, E, F, G, H;
}

int Sum(in BigValue v) => v.A + v.B + v.C + v.D + v.E + v.F + v.G + v.H;

Pooling

Prefer ArrayPool<T> or object pools in hot paths to reduce GC pressure.

CTA

Next up: Part 3 — Production-Ready Practices (resource management, testing/diagnostics, logging/telemetry, security & reliability). Share your performance tips in the comments!

Series Navigation

Part 1 - Core Foundations for Enterprise C#

Part 3 - Production-Ready C#

Part 1 - Core Foundations for Enterprise C#: OOP & SOLID, Clean Architecture, and Type Semantics

Seigo Kitamura — Wed, 07 Jan 2026 11:03:15 +0000

Excerpt

This post distills the core C# foundations enterprise teams expect: applying OOP & SOLID in real systems, enforcing clean architecture boundaries, and choosing the right type semantics (class vs record vs struct). We also cover string immutability, when to use StringBuilder, and LINQ pitfalls that affect performance and correctness.

Core Foundations for Enterprise C

Object-Oriented Programming (OOP): Concepts & Pillars
OOP & SOLID (what scales in real systems)
Clean Architecture Boundaries (controllers, application, domain, infra)
Types: class vs record vs struct (including record struct)
Strings & Collections (immutability, StringBuilder, LINQ pitfalls)

Object-Oriented Programming (OOP): Concepts & Pillars

What is OOP and how does it help us?

Object-Oriented Programming (OOP) is a paradigm that organizes software design around data, or objects, rather than functions and logic. OOP helps us build scalable, maintainable, and reusable code by modeling real-world entities and their interactions.

The Five Pillars of OOP:

Encapsulation: Bundling data and methods that operate on that data within one unit (class), and restricting direct access to some of the object's components.
Abstraction: Hiding complex implementation details and exposing only the necessary features.
Inheritance: Creating new classes from existing ones, inheriting fields and behaviors.
Polymorphism: Allowing objects to be treated as instances of their parent class, enabling one interface to be used for different underlying forms (data types).
Composition (modern best practice): Building complex types by combining objects, favoring "has-a" relationships over "is-a" inheritance.

1. Encapsulation

public class BankAccount
{
    private decimal _balance; // private field

    public void Deposit(decimal amount)
    {
        if (amount > 0) _balance += amount;
    }

    public decimal Balance => _balance; // read-only property
}

2. Abstraction

public abstract class Shape
{
    public abstract double Area();
}

public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}

3. Inheritance

public class Animal
{
    public void Eat() => Console.WriteLine("Eating...");
}

public class Dog : Animal
{
    public void Bark() => Console.WriteLine("Woof!");
}

var dog = new Dog();
dog.Eat();
dog.Bark();

4. Polymorphism

public class Cat : Animal
{
    public void Meow() => Console.WriteLine("Meow!");
}

public void MakeAnimalSpeak(Animal animal)
{
    animal.Eat();
}

MakeAnimalSpeak(new Dog());
MakeAnimalSpeak(new Cat());

5. Composition

public class Engine
{
    public void Start() => Console.WriteLine("Engine started.");
}

public class Car
{
    private readonly Engine _engine = new Engine();
    public void Start() => _engine.Start();
}

OOP & SOLID (what scales in real systems)

Key ideas

Favor composition over inheritance; program to interfaces for testability.
SOLID principles guide large codebases:
- Single Responsibility → keep classes focused.
- Open/Closed → extend via interfaces/strategies.
- Liskov Substitution → subtypes should be substitutable.
- Interface Segregation → small, purpose-fit interfaces.
- Dependency Inversion → depend on abstractions; use DI containers.

Example: Dependency Inversion + Interface Segregation

public interface IEmailSender
{
    Task SendAsync(string to, string subject, string body, CancellationToken ct);
}

public class SmtpEmailSender : IEmailSender
{
    public Task SendAsync(string to, string subject, string body, CancellationToken ct)
    {
        return Task.CompletedTask;
    }
}

public class NotificationService
{
    private readonly IEmailSender _sender;
    public NotificationService(IEmailSender sender) => _sender = sender;

    public Task NotifyPasswordResetAsync(string userEmail, CancellationToken ct) =>
        _sender.SendAsync(userEmail, "Reset Your Password", "Link...", ct);
}

Immutability reduces bugs

public record ResetRequest(string Email, DateTime RequestedAt); // immutable DTO

public class User {
    public string Name { get; init; } // init-only setter for object initializers
    public string Email { get; init; }
}

Clean Architecture Boundaries (controllers, application, domain, infra)

Keep layers focused and avoid leaking concerns across boundaries.

+-----------------------------------------------------------+
|                   Presentation (Controllers)              |
|      - map HTTP <-> application use cases                 |
+-----------------------------------------------------------+
|                 Application (Services)                    |
|      - orchestrates use cases, coordinates domain         |
+-----------------------------------------------------------+
|                     Domain (Core)                         |
|      - entities, value objects, policies                  |
+-----------------------------------------------------------+
|               Infrastructure (Adapters)                   |
|      - EF Core, HTTP clients, storage, messaging          |
+-----------------------------------------------------------+

Controller → Service → Domain

[ApiController]
[Route("api/users")]
public class UsersController : ControllerBase {
    private readonly IUserService _service;
    public UsersController(IUserService service) => _service = service;

    [HttpPost("reset")]
    public async Task<IActionResult> Reset([FromBody] ResetRequest req, CancellationToken ct) {
        await _service.RequestPasswordResetAsync(req.Email, ct);
        return Accepted();
    }
}

public interface IUserService {
    Task RequestPasswordResetAsync(string email, CancellationToken ct);
}

Types: class vs record vs struct (including record struct)

When to choose what

class → Reference type; polymorphism, inheritance, services/entities. Default equality is reference.
record → Reference type with value-based equality + with expressions; ideal for DTOs/value models.
struct → Value type; lightweight and allocation-free for tiny models. Avoid large structs (copy cost).
record struct → Value type with record features (value equality) for small immutable models.

Equality differences

public class UserClass { public string Name { get; init; } }
public record UserRecord(string Name);

var c1 = new UserClass { Name = "A" };
var c2 = new UserClass { Name = "A" };
Console.WriteLine(Equals(c1, c2)); // False (reference equality)

var r1 = new UserRecord("A");
var r2 = new UserRecord("A");
Console.WriteLine(Equals(r1, r2)); // True (value-based equality)

Records: non-destructive mutation

public record Person(string Name, int Age);
var p1 = new Person("Alice", 30);
var p2 = p1 with { Age = 31 };

Structs: keep tiny and often immutable

public readonly struct Point {
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
}

Strings & Collections (immutability, StringBuilder, LINQ pitfalls)

Strings are immutable → avoid heavy concatenation with +

var sb = new StringBuilder();
for (int i = 0; i < 1000; i++) sb.Append(i).Append(',');
var result = sb.ToString();

LINQ: deferred execution & materialization

var query = numbers.Where(n => n % 2 == 0); // deferred
numbers.Add(2); // changes the source before enumeration
var list = query.ToList(); // materialized; includes newly added 2

Pitfalls & tips

Be mindful of multiple enumerations (cache with ToList() when necessary).
LINQ in hot loops can add allocations; measure before optimizing.

CTA

If you found this useful, check out Part 2 (Performance & Concurrency Essentials) and Part 3 (Production-Ready Practices). Post your own tips or war stories in the comments—let’s build a living checklist for backend engineers.

Series Navigation

Part 2 - Performance & Concurrency Essentials in C#

Part 3 - Production-Ready C#