Comment initialiser un objet à l'aide asynchrone attendent modèle

J'ai un blog qui décrit plusieurs approches pour async construction.

Je recommande asynchrone usine méthode décrite par Reed, mais parfois, c'est pas possible (par exemple, l'injection de dépendance). Dans ces cas, vous pouvez utiliser une initialisation asynchrone modèle comme ceci:

public sealed class MyType
{
    public MyType()
    {
        Initialization = InitializeAsync();
    }

    public Task Initialization { get; private set; }

    private async Task InitializeAsync()
    {
        //Asynchronously initialize this instance.
        await Task.Delay(100);
    }
}

Vous pouvez alors construire le type normalement, mais gardez à l'esprit que la construction seulement commence l'initialisation asynchrone. Quand vous avez besoin le type à être initialisé, votre code peut faire:

await myTypeInstance.Initialization;

Noter que si Initialization est déjà terminée, l'exécution (de façon synchrone) se poursuit après la await.

Si vous souhaitez une réelle propriété asynchrone, j'ai un blog pour que, trop. Votre situation sons comme il peut bénéficier de AsyncLazy<T>:

public sealed class MyClass
{
    public MyClass()
    {
        MyProperty = new AsyncLazy<int>(async () =>
        {
            await Task.Delay(100);
            return 13;
        });
    }

    public AsyncLazy<int> MyProperty { get; private set; }
}

OriginalL'auteur Stephen Cleary

Vous pouvez utiliser mon AsyncContainer conteneur IoC, qui soutient exactement le même scénario que vous.

Il prend également en charge d'autres pratique des scénarios tels que async initialiseurs, au moment de l'exécution conditionnelle d'usines, dépendent async et de la synchronisation de l'usine de fonctions

//The email service factory is an async method
public static async Task<EmailService> EmailServiceFactory() 
{
  await Task.Delay(1000);
  return new EmailService();
}

class Service
{
     //Constructor dependencies will be solved asynchronously:
     public Service(IEmailService email)
     {
     }
} 

var container = new Container();
//Register an async factory:
container.Register<IEmailService>(EmailServiceFactory);

//Asynchronous GetInstance:
var service = await container.GetInstanceAsync<Service>();

//Safe synchronous, will fail if the solving path is not fully synchronous:
var service = container.GetInstance<Service>();

OriginalL'auteur rafael

Je sais que c'est une vieille question, mais c'est le premier qui apparaît sur Google et, franchement, la accepté de répondre est une mauvaise réponse. Vous ne devez jamais forcer un retard de sorte que vous pouvez utiliser l'attendent de l'opérateur.

Une meilleure approche pour une méthode d'initialisation:

private async Task<bool> InitializeAsync()
{
    try{
        //Initialize this instance.
    }

    catch{
        //Handle issues
        return await Task.FromResult(false);
    }

    return await Task.FromResult(true);
}

Cela utiliser le async cadre d'initialiser un objet, mais ensuite elle retourne une valeur booléenne.

Pourquoi est-ce une meilleure approche? Tout d'abord, vous n'êtes pas forcer un retard dans votre code qui à mon humble avis totalement défait le but de l'utilisation de l'async cadre. Deuxièmement, c'est une bonne règle de pouce à retourner quelque chose à partir d'une méthode asynchrone. De cette façon, vous savez si votre méthode async effectivement travaillées/est-ce qu'il était censé. De retour juste Tâche est l'équivalent de retour void sur une non-méthode async.

OriginalL'auteur John Doeses