What is the problem? Async await syntax gives us the most straightforward way to write asynchronous code. However, such construction cannot be used in certain scenarios. For instance, using async await keywords is prohibited in constructors. There are many reasons why it is not possible in the existing language version. Probably, one of the obvious ones is that async methods would return or to be able to properly handle exceptions without crashing the process, and trivially to be able to wait until the async operation is completed. Task Task<T> And if we simply take the following class, build the library containing it, and then look at disassembled code. public class MyObject
{
    public MyObject()
    {
        //diligently initializing
    }
} We will see the following line. instance void [System.Runtime]System.Object::.ctor() where the keyword indicates that the method is an instance method, meaning it is called on an instance of the class, not on the class itself (which would be indicated by the static keyword). instance So, technically, it calls some method (constructor) on the already existing object to initialize it. Could it be made asynchronous hypothetically? public class MyObject
{
    public async MyObject()
    {
        await InitializeAsync();
    }
} Of course, yes, everything is possible in our world; it only depends on the price and whether it will solve any real problem without introducing new complications and tradeoffs. I believe that developers have had discussions about it many times, and they clearly understand the feasibility and meaningfulness of incorporating this change. C# language However, even without language in-built such a feature, we can solve this problem. Ways to overcome There are plenty of approaches that could be used to achieve the asynchronous initialization. Async to sync If we are only allowed to have sync operation in constructors, we can intuitively apply the approach. async to sync public class MyBestObject
{
    public MyBestObject()
    {
        InitializeAsync().GetAwaiter().GetResult();
    }

    private async Task InitializeAsync()
    {
        //diligently initializing

        await Task.Delay(100);
    }
} This approach is not so bad if there is no synchronization context in place and the async operation is relatively fast, but in general, it is not a recommended practice since it is based on a lot of assumptions about the executing environment and details of the async operation. It leads to inefficient resource consumption, sudden deadlocks in UI applications, and a common violation of the async programming idea of “async all the way.“ Async factory A quite standard way for solving this problem is to use factories. public class MyBestService
{
    public async Task InitializeAsync() 
    {
        //diligently initializing

        await Task.Delay(100);
    }
}

public interface IMyBestServiceFactory
{
    Task<MyBestService> CreateAsync(CancellationToken cancellationToken);
}

public sealed class MyBestServiceFactory : IMyBestServiceFactory
{
    public MyBestServiceFactory()
    {
    }

    public async Task<MyBestService> CreateAsync(CancellationToken cancellationToken)
    {
        var service = new MyBestService();
        await service.InitializeAsync(cancellationToken);
        return service;
    }
} We could either use the static method in class or even specify a dedicated factory for that purpose. The second option is a little bit more compatible with the pattern since you can request in any class and then just call the method. MyBestService Dependency Injection IMyBestServiceFactory CreateAsync The main drawback of this approach is additional coupling since you (any class uses ) need to control the lifetime of a newly created object. IMyBestServiceFactory Additionally, it requires adapting solutions that use reflection ( ) or expressions ( ) to create and initialize instances. Activate.CreateInstace Expression.New Async initialization We could do the following trick to avoid problems with the pattern. Async Factory public class MyBestService
{
    private readonly Task _initializeTask;

    public MyBestService()
    {
        _initializeTask = InitializeAsync();
    }

    public async Task DoSomethingAsync() 
    {
        await _initializeTask;

        // Do something async
    }

    private async Task InitializeAsync()
    {
        //diligently initializing

        await Task.Delay(100);
    }
} As you can see, we are beginning asynchronous initialization in the constructor and saving the reference to the started task. Then, before doing any meaningful operation, we check that is completed by simply awaiting it. _initializeTask The using of this approach is very usual both in cases with a self-instantiating way of objects and IoC container. var myBestService = new MyBestService();
await myBestService.DoSomethingAsync(); However, this approach has several drawbacks: Lack of control over the initialization process. For instance, we cannot simply pass . CancellationToken It gives the caller an incompletely instantiated object for a while. Although it does not seem a problem in general, it could lead to more complicated debugging if the initialization operation takes too long. Also, calling operation timeout might be less than the required amount of time for this particular object which apparently will lead to issues during the execution. Real example For applications to access Azure services like storage, key vault, or cognitive services, authenticating with Azure is mandatory, regardless of their deployment environment - on Azure, on-premises, or locally during development. There are several ways it could be achieved, and one of the most secure ones is utilising the approach with the class in .NET DefaultAzureCredential That’s what Microsoft says about it The class provided by the Azure SDK allows apps to use different authentication methods depending on the environment they're run in. This allows apps to be promoted from local development to test environments to production without code changes. You configure the appropriate authentication method for each environment and will automatically detect and use that authentication method. The use of should be preferred over manually coding conditional logic or feature flags to use different authentication methods in different environments. DefaultAzureCredential DefaultAzureCredential DefaultAzureCredential So, in order to securely store PII (Personally Identifiable Information) which can be either Full name, Phone Number, Credit card number, or Social security number, we would like to encrypt it before storing it somewhere and provide viewing original value with only limited access. One of the possible ways is to use AzureKeyVault API for encryption and decryption. Although there is no huge impact of creating every time, to reduce latency and improve efficiency, it is preferable to have a single instance of it for the whole application. DefaultAzureCredential So, to prepare for encryption and decryption API, we need to have the following lines CryptographyClient var tokenCredential = new DefaultAzureCredential();
var keyClient = new KeyClient(new Uri(_configuration.KeyVaultUri), tokenCredential);
KeyVaultKey key = await keyClient.GetKeyAsync(_configuration.KeyName);
_cryptographyClient = new CryptographyClient(key.Id, tokenCredential); To avoid running them on every request, we can utilise described above Async initialisation internal sealed class DefaultAzureVaultAdapter : IAzureVaultAdapter
{
    private readonly AzureVaultConfiguration _configuration;
    private EncryptionAlgorithm _encryptionAlgorithm = EncryptionAlgorithm.RsaOaep256;
    private CryptographyClient _cryptographyClient = null!;
    private Task _initializationTask = null!;

    public DefaultAzureVaultAdapter(AzureVaultConfiguration configuration)
    {
        _configuration = configuration;
        _initializationTask = InitializeAsync();
    }

    public async Task<string> EncryptAsync(string value, CancellationToken cancellationToken)
    {
        await _initializationTask;

        byte[] inputAsByteArray = Encoding.UTF8.GetBytes(value);

        EncryptResult encryptResult = await _cryptographyClient.EncryptAsync(_encryptionAlgorithm, inputAsByteArray, cancellationToken);

        return Convert.ToBase64String(encryptResult.Ciphertext);
    }

    public async Task<string> DecryptAsync(string value, CancellationToken cancellationToken)
    {
        await _initializationTask;

        byte[] inputAsByteArray = Convert.FromBase64String(value);

        DecryptResult decryptResult = await _cryptographyClient.DecryptAsync(_encryptionAlgorithm, inputAsByteArray, cancellationToken);

        return Encoding.Default.GetString(decryptResult.Plaintext);
    }

    private async Task InitializeAsync()
    { 
        if (_cryptographyClient is not null)
            return;

        var tokenCredential = new DefaultAzureCredential();
        var keyClient = new KeyClient(new Uri(_configuration.KeyVaultUri), tokenCredential);
        KeyVaultKey key = await keyClient.GetKeyAsync(_configuration.KeyName);
        _cryptographyClient = new CryptographyClient(key.Id, tokenCredential);
    }
} And finally, register our with a singleton in IoC container. AzureVaultAdapter public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddAzureVaultAdapter(this IServiceCollection services)
    {
        services.TryAddSingleton<IAzureVaultAdapter, DefaultAzureVaultAdapter>();
        return services;
    }
} Conclusion In this article, I covered several approaches for asynchronous object initialisation. Understanding requirements is the key to choosing the right approach. You can find the source code used to describe these patterns in this repository. https://github.com/alex-popov-stenn/CSharpAsyncInitPatterns/tree/main Thank you for reading! See you next time!

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Augmentastic || Augmented Reality

Asynchronous Initialization in C#: Overcoming Constructor Limitations

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

A Detailed Guide to String Concatenation in .NET

From Junior to Senior Node.js Developer: Lessons Learned

An Introduction to JavaScript Functions and Asynchronous Programming with Callbacks

How to do Asynchronous Programming in Flutter with Dart

Pin Safety: Understanding Pinning in Rust Futures

The Complete Asynchronous Programming Primer for Unity Development

A Detailed Guide to String Concatenation in .NET

From Junior to Senior Node.js Developer: Lessons Learned

An Introduction to JavaScript Functions and Asynchronous Programming with Callbacks

How to do Asynchronous Programming in Flutter with Dart

Pin Safety: Understanding Pinning in Rust Futures

The Complete Asynchronous Programming Primer for Unity Development

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps