3. Advanced Functions & Methods in C# (Senior-Level)

C# provides a robust set of features for writing efficient, maintainable, and high-performance functions and methods. This article explores advanced topics essential for senior-level developers, focusing on asynchronous programming, functional paradigms, performance optimizations, dependency injection, reflection, and source generation.

In this post, I'll cover the following topics:

• Async & Await in Methods
• Functional Programming Concepts in C#
• Expression-Bodied Methods
• Performance Considerations in Methods
• Method Injection & Dependency Injection (DI)
• Reflection & Dynamic Method Invocation
• Source Generators & Code Generation for Methods

1??1?? Async & Await in Methods

Why Asynchronous Programming Matters

Modern applications demand responsiveness and efficiency. Asynchronous programming in C# enables non-blocking execution, allowing applications to remain responsive while waiting for I/O operations, database queries, or network requests. Properly using asynchronous methods prevents deadlocks, enhances scalability, and improves performance in high-concurrency applications.

Task, Task, and async void

• Task represents an operation that can run asynchronously and be awaited.
• Task<T> is a generic version that returns a result.
• async void should only be used for event handlers, as it does not allow proper exception handling and can cause unhandled exceptions that crash applications.

Handling Exceptions in Async Methods

Using try/catch/finally in async methods ensures proper error handling:

public async Task<int> FetchDataAsync()
{
    try
    {
        return await GetDataFromApi();
    }
    catch (HttpRequestException ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
        return -1;
    }
    finally
    {
        Console.WriteLine("Async operation completed.");
    }
}
        

When to Use ConfigureAwait(false)

Calling .ConfigureAwait(false) improves performance in library code by avoiding context switching:

await SomeAsyncMethod().ConfigureAwait(false);
        

This is useful in non-UI contexts where resuming on the original synchronization context is unnecessary. It can prevent potential deadlocks in ASP.NET applications when working with SynchronizationContext.

Best Practices for Asynchronous Methods

• Avoid async void except for event handlers.
• Use ConfigureAwait(false) in library code.
• Ensure all async methods are awaited to prevent unobserved exceptions.
• Leverage ValueTask<T> where applicable for performance improvements in high-throughput scenarios.

1??2?? Functional Programming Concepts in C#

Higher-Order Functions

Functions that take other functions as parameters or return functions enable flexible and reusable code:

Func<int, int, int> add = (a, b) => a + b;
        

Closures and Capturing Variables

Closures allow functions to capture and persist variables beyond their scope:

Func<int, int> multiplier(int factor)
{
    return x => x * factor;
}
var triple = multiplier(3);
Console.WriteLine(triple(10)); // Output: 30
        

Partial Application and Currying

Currying allows breaking down a function into smaller functions, facilitating reuse:

Func<int, Func<int, int>> curriedAdd = a => b => a + b;
var addFive = curriedAdd(5);
Console.WriteLine(addFive(3)); // Output: 8
        

Immutability and Pure Functions

Immutability enhances reliability, reducing side effects in code:

public int Square(int x) => x * x; // No side effects
        

Pure functions always return the same output for given inputs, improving predictability.

Functional Composition

Combining functions enhances reusability:

Func<int, int> doubleIt = x => x * 2;
Func<int, int> increment = x => x + 1;
Func<int, int> composed = x => doubleIt(increment(x));
Console.WriteLine(composed(3)); // Output: 8
        

1??3?? Expression-Bodied Methods

Expression-bodied members allow concise method definitions, improving readability and maintainability:

public class MathUtils
{
    public int Add(int a, int b) => a + b;
}
        

They are especially useful for one-liner methods, reducing code clutter.

1??4?? Performance Considerations in Methods

Avoiding Excessive Method Calls (Inlining)

Inlining minimizes method call overhead:

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int Multiply(int x, int y) => x * y;
        

Using readonly struct for Performance

Passing readonly struct by reference reduces copying overhead:

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

Benchmarking Method Execution Time

Use BenchmarkDotNet to measure performance:

[Benchmark]
public void MyMethod()
{
    // Code to benchmark
}
        

Benchmarking helps identify bottlenecks and optimize code for efficiency.

1??5?? Method Injection & Dependency Injection (DI)

Avoiding Static Methods in DI Contexts

Static methods limit flexibility and testability. Dependency injection (DI) enables dynamic dependency management.

Constructor Injection vs. Method Injection

Constructor injection is preferred for mandatory dependencies, while method injection suits optional dependencies:

public class Service
{
    private readonly ILogger _logger;
    public Service(ILogger logger) => _logger = logger;
    public void Process() => _logger.Log("Processing...");
}
        

Testable and Loosely Coupled Code

Interfaces improve testability by enabling dependency substitution in unit tests:

public interface IRepository
{
    void Save(string data);
}
        

1??6?? Reflection & Dynamic Method Invocation

MethodInfo.Invoke() for Runtime Method Calls

Reflection allows invoking methods dynamically:

MethodInfo method = typeof(MyClass).GetMethod("MyMethod");
method.Invoke(instance, null);
        

Performance Considerations

Reflection introduces overhead. Use cautiously in performance-sensitive applications.

Use Cases

• Serialization frameworks
• Plugin architectures
• Dependency injection containers

1??7?? Source Generators & Code Generation for Methods

Introduction to Roslyn Source Generators

Source generators automate code creation at compile time, reducing boilerplate.

Practical Use Cases

• Logging wrappers
• Auto-generating repetitive methods
• Optimizing serialization logic

Conclusion

Mastering these advanced C# method concepts enhances maintainability, performance, and scalability. Leveraging asynchronous programming, functional paradigms, and source generators equips developers to build efficient and robust applications. Continuously refining these techniques fosters professional growth in software development.

Stay tuned for more insights into C# programming best practices!

P.S. Want to become Next-Gen Software Engineer? ????????

Subscribe to the branded new Next-Gen Software Engineer newsletter and get two practical articles every week.

Follow me on LinkedIn.