С помощью асинхронного повторного входа используйте оригинальный асинхронный вызов? [Дубликат]

Я знаю, что это старый вопрос, но он первый, который появляется в Google, и, откровенно говоря, принятый ответ - плохой ответ. Вы никогда не должны затягивать задержку, чтобы вы могли использовать оператор ожидания.

Лучший подход к методу инициализации:

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

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

    return await Task.FromResult(true);
}

Это будет использовать инфраструктуру async для инициализации вашего объекта , но затем он вернет логическое значение.

Почему это лучший подход? Во-первых, вы не заставляете задерживать свой код, который ИМХО полностью поражает целью использования инфраструктуры async. Во-вторых, это хорошее правило, чтобы вернуть что-то из метода асинхронности. Таким образом, вы знаете, действительно ли ваш асинхронный метод работал / делал то, что предполагалось. Возвращение только задачи - это эквивалент возвращаемого значения void по неасинхронному методу.

Вы можете использовать мой контейнер [y0] AsyncContainer IoC, который поддерживает тот же самый сценарий, что и вы.

Он также поддерживает другие удобные сценарии, такие как инициализаторы асинхронизации, условные фабрики времени выполнения, зависят от асинхронных и синхронных заводских функций

//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>();

Один из возможных вариантов заключается в том, чтобы перенести это на заводский метод вместо использования конструктора.

После этого ваш заводский метод может вернуть Task<ServiceProvider>, что позволит вам выполнить инициализацию асинхронно, но не возвращать сконструированные ServiceProvider до тех пор, пока ImportantValue не будет (асинхронно) вычисляться.

Это позволит вашим пользователям писать код наподобие:

var sp = await ServiceProvider.CreateAsync();
int iv = sp.ImportantValue; // Will be initialized at this point

Это небольшая модификация шаблона @StephenCleary инициализации async.

Разница в том, что вызывающему абоненту не нужно «запоминать» await InitializationTask или даже знать что-либо о initializationTask (на самом деле теперь он изменен на закрытый).

Способ, которым он работает, заключается в том, что в каждом методе, который использует инициализированные данные, есть начальный вызов await _initializationTask. Это мгновенно возвращается во второй раз, потому что сам объект _initializationTask будет иметь логический набор (IsCompleted, который проверяет механизм ожидания), поэтому не стоит беспокоиться об инициализации несколько раз.

Единственный улов, о котором я знаю, - вы не должны забывать его вызывать в каждом методе, который использует данные.

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

    private Task _initializationTask;

    private async Task InitializeAsync()
    {
        // Asynchronously initialize this instance.
        _customers = await LoadCustomersAsync();
    }

    public async Task<Customer> LookupCustomer(string name)
    {
         // Waits to ensure the class has been initialized properly
         // The task will only ever run once, triggered initially by the constructor
         // If the task failed this will raise an exception
         // Note: there are no () since this is not a method call
         await _initializationTask;

         return _customers[name];
    }

    // one way of clearing the cache
    public void ClearCache()
    {
         InitializeAsync();
    }

    // another approach to clearing the cache, will wait until complete
    // I don't really see a benefit to this method since any call using the
    // data (like LookupCustomer) will await the initialization anyway
    public async Task ClearCache2()
    {
         await InitializeAsync();
    }
 }