Advanced C# Techniques

Advanced C# Techniques

Now that we've covered Introduction to CI/CD in Azure and Azure Cloud Overview, we can zoom into the implementation layer: the C# code you will be expected to reason about in senior backend interviews.

For a senior C# backend developer, “advanced” usually does not mean obscure syntax trivia. It means you can explain:

• Why async code scales under I/O pressure
• How cancellation, streaming, and backpressure affect APIs
• Where allocations appear and how to reduce them
• How modern C# features improve clarity without hiding tradeoffs
• How to write code that behaves predictably in production

In interviews, your goal is to connect language features to engineering outcomes: latency, reliability, maintainability, and operational safety.

Async beyond await

A strong interview answer separates concurrency from parallelism.

• Concurrency: multiple operations are in progress at the same time.
• Parallelism: multiple operations execute at the same physical time on different cores.

In backend C#, async/await is most valuable for I/O-bound work: database calls, HTTP calls, blob storage, queues, and external APIs. It lets the thread return to the pool while the operation waits.

Senior-level points

• Prefer Task / Task<T> for asynchronous operations.
• Accept and pass CancellationToken through call chains.
• Avoid blocking async code with .Result, .Wait(), or excessive Task.Run.
• Use Task.WhenAll for independent I/O calls, but understand failure behavior.

Task.WhenAll does not make slow dependencies fast, but it can reduce total latency when calls are independent.

```csharp
using System;
using System.Diagnostics;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main()
    {
        var stopwatch = Stopwatch.StartNew();

        Task<string> userTask = FetchAsync("user", 700);
        Task<string> ordersTask = FetchAsync("orders", 900);

        string[] results = await Task.WhenAll(userTask, ordersTask);

        stopwatch.Stop();

        Console.WriteLine(string.Join(" | ", results));
        Console.WriteLine($"Elapsed: {stopwatch.ElapsedMilliseconds}ms");
    }

    private static async Task<string> FetchAsync(string name, int delayMs)
    {
        await Task.Delay(delayMs);
        return $"Fetched {name}";
    }
}
```

You are reviewing a C# API endpoint that calls two independent downstream services. Each call is I/O-bound and supports cancellation.

Which senior-level approach is usually best?

Allocation-aware C

High-throughput backend services often spend surprising time allocating memory and triggering garbage collection.

You do not need to micro-optimize every line. But in hot paths, senior engineers recognize tools like:

• Span<T>: stack-only view over contiguous memory
• ReadOnlySpan<T>: read-only view, useful for parsing
• Memory<T> / ReadOnlyMemory<T>: span-like types that can live across async boundaries
• ArrayPool<T>: reuse arrays to reduce allocations

Interview framing

A good answer is balanced:

“I would first measure. If profiling shows allocations in a hot path, I might use spans, pooling, or streaming to reduce pressure. I would avoid making normal business code unreadable without evidence.”

```csharp
using System;

public class Program
{
    public static void Main()
    {
        string raw = "order-12345";

        ReadOnlySpan<char> text = raw.AsSpan();
        ReadOnlySpan<char> prefix = text.Slice(0, 5);
        ReadOnlySpan<char> id = text.Slice(6);

        Console.WriteLine($"Prefix: {prefix.ToString()}");
        Console.WriteLine($"Id: {id.ToString()}");

        Span<int> numbers = stackalloc int[] { 3, 1, 4 };
        numbers.Sort();

        Console.WriteLine($"Sorted: {string.Join(", ", numbers.ToArray())}");
    }
}
```

Span<T> is a ref-like type, so it can safely be stored in a normal class field and used later after an await.

Patterns and records

Modern C# gives you expressive tools for modeling decisions and immutable data.

Useful interview talking points:

• record types are useful for value-like models, DTOs, messages, and results.
• Pattern matching can replace fragile chains of type checks and nested conditionals.
• Switch expressions are concise, but should remain readable.
• Immutability reduces accidental mutation, especially when data flows through async pipelines.

This is not a replacement for good object design—we'll revisit object-oriented fundamentals later. Here, focus on how modern C# can make backend code clearer and safer.

```csharp
using System;

public record Payment(decimal Amount, string Currency, bool IsPriority);

public class Program
{
    public static void Main()
    {
        var payments = new[]
        {
            new Payment(50, "USD", false),
            new Payment(2000, "USD", true),
            new Payment(100, "EUR", false)
        };

        foreach (var payment in payments)
        {
            Console.WriteLine($"{payment} => {Route(payment)}");
        }
    }

    private static string Route(Payment payment) => payment switch
    {
        { IsPriority: true, Amount: >= 1000 } => "Manual review + fast lane",
        { Currency: "USD", Amount: < 1000 } => "Domestic processor",
        { Currency: "EUR" } => "EU processor",
        _ => "Default processor"
    };
}
```

Streaming instead of buffering

Many backend performance problems come from loading everything into memory before processing.

Instead of:

1. Fetch all rows
2. Store all rows in a list
3. Process the list
4. Return everything

Consider streaming when the use case allows it:

1. Fetch one item or page
2. Process it
3. Yield it
4. Let the caller consume progressively

In C#, asynchronous streaming is represented with IAsyncEnumerable<T>. It is useful when reading paged APIs, database cursors, queue batches, or large files.

Senior caution

Streaming is not automatically better. It changes error timing, cancellation behavior, serialization behavior, and resource lifetimes. Use it when progressive consumption or memory reduction is worth those tradeoffs.

Fill in the blank:

The C# abstraction commonly used to represent an asynchronous stream of values is ______.

Nullable reference discipline

Nullable reference types help make absence explicit. In senior backend code, this matters because null bugs often appear at integration boundaries: HTTP payloads, database records, configuration, cache values, and third-party responses.

Practical habits

• Enable nullable reference types in new projects.
• Treat warnings as design feedback, not noise.
• Use string? when null is valid.
• Validate external input at boundaries.
• Prefer clear result models over returning ambiguous nulls.

Interview answer pattern

“I use nullable annotations to document intent. At boundaries I validate aggressively, then keep the internal domain as non-null as possible. That reduces defensive checks throughout the core code.”

This connects well to the CI/CD quality gates from the first lesson: nullable warnings can become part of build quality rather than only runtime discovery.

Production-aware C

Advanced C# is also about writing code that can be diagnosed after deployment.

For backend interviews, mention:

• Structured logs instead of string-only messages
• Correlation IDs across async calls
• Metrics for latency, error rate, throughput, and saturation
• Tracing for request flow across dependencies
• Avoiding swallowed exceptions in background work

You already saw in Azure Cloud Overview that cloud systems must be designed for operations. In C#, that means your code should expose enough signal for Azure Monitor, Application Insights, OpenTelemetry, or your logging platform to explain what happened.

Senior phrase

“I want failures to be observable, not mysterious.”

Advanced C# interview cheat sheet

Use this structure when answering senior C# questions.

1. Async and scalability

Say:

“For I/O-bound work, I use async all the way, pass cancellation tokens, avoid blocking calls, and use Task.WhenAll when operations are independent.”

2. Performance tradeoffs

Say:

“I measure first. If profiling shows allocation pressure, I consider spans, pooling, streaming, or reducing intermediate collections.”

3. Modern language features

Mention records, pattern matching, nullable reference types, and async streams—but explain the problem they solve.

4. Production readiness

Connect code choices to logs, metrics, tracing, cancellation, and graceful failure.

5. Balanced senior answer

Avoid absolute claims like “always use X.” Prefer:

“Given this workload, I would choose X because it improves Y, while watching for tradeoff Z.”

Next, we’ll move from language-level techniques into Microservices Architecture, where these C# decisions become part of larger distributed system design.