Restituzione di IAsyncEnumerable <T> e NotFound dal controller core Asp.Net

Qual è la firma giusta per un'azione del controller che restituisce un IAsyncEnumerable<T>e un NotFoundResultma viene comunque elaborata in modo asincrono?

Ho usato questa firma e non viene compilata perché IAsyncEnumerable<T>non è prevedibile:

[HttpGet]
public async Task<IActionResult> GetAll(Guid id)
{
    try
    {
        return Ok(await repository.GetAll(id)); // GetAll() returns an IAsyncEnumerable
    }
    catch (NotFoundException e)
    {
        return NotFound(e.Message);
    }
}

Questo compila bene ma la sua firma non è asincrona. Quindi sono preoccupato se bloccherà o meno i thread del pool di thread:

[HttpGet]
public IActionResult GetAll(Guid id)
{
    try
    {
        return Ok(repository.GetAll(id)); // GetAll() returns an IAsyncEnumerable
    }
    catch (NotFoundException e)
    {
        return NotFound(e.Message);
    }
}

Ho provato a usare un await foreachloop in questo modo ma ovviamente non si sarebbe nemmeno compilato:

[HttpGet]
public async IAsyncEnumerable<MyObject> GetAll(Guid id)
{
    IAsyncEnumerable<MyObject> objects;
    try
    {
        objects = contentDeliveryManagementService.GetAll(id); // GetAll() returns an IAsyncEnumerable
    }
    catch (DeviceNotFoundException e)
    {
        return NotFound(e.Message);
    }

    await foreach (var obj in objects)
    {
        yield return obj;
    }
}

L'opzione 2, che passa un'implementazione IAsyncEnumerable<>nella Okchiamata, va bene. L'impianto idraulico ASP.NET Core si occupa dell'enumerazione ed è IAsyncEnumerable<>aggiornato alla versione 3.0.

Ecco la chiamata dalla domanda, ripetuta per il contesto:

return Ok(repository.GetAll(id)); // GetAll() returns an IAsyncEnumerable

La chiamata a Okcrea un'istanza di OkObjectResult, che eredita ObjectResult. Il valore passato a Okè di tipo object, che si svolge in ObjectResult's Valueproprietà. ASP.NET Core MVC utilizza il modello di comando , per cui il comando è un'implementazione di IActionResulte viene eseguito utilizzando un'implementazione di IActionResultExecutor<T>.

Per ObjectResult, ObjectResultExecutorviene utilizzato per trasformare il ObjectResultin una risposta HTTP. È l' implementazione di ObjectResultExecutor.ExecuteAsyncquesto è IAsyncEnumerable<>-aware:

public virtual Task ExecuteAsync(ActionContext context, ObjectResult result)
{
    // ...

    var value = result.Value;

    if (value != null && _asyncEnumerableReaderFactory.TryGetReader(value.GetType(), out var reader))
    {
        return ExecuteAsyncEnumerable(context, result, value, reader);
    }

    return ExecuteAsyncCore(context, result, objectType, value);
}

Come mostra il codice, la Valueproprietà viene controllata per vedere se implementa IAsyncEnumerable<>(i dettagli sono nascosti nella chiamata a TryGetReader). In tal caso, ExecuteAsyncEnumerableviene chiamato, che esegue l'enumerazione e quindi passa il risultato enumerato in ExecuteAsyncCore:

private async Task ExecuteAsyncEnumerable(ActionContext context, ObjectResult result, object asyncEnumerable, Func<object, Task<ICollection>> reader)
{
    Log.BufferingAsyncEnumerable(Logger, asyncEnumerable);

    var enumerated = await reader(asyncEnumerable);
    await ExecuteAsyncCore(context, result, enumerated.GetType(), enumerated);
}

readernello snippet sopra è dove si verifica l'enumerazione. È sepolto un po ', ma puoi vedere la fonte qui :

private async Task<ICollection> ReadInternal<T>(object value)
{
    var asyncEnumerable = (IAsyncEnumerable<T>)value;
    var result = new List<T>();
    var count = 0;

    await foreach (var item in asyncEnumerable)
    {
        if (count++ >= _mvcOptions.MaxIAsyncEnumerableBufferLimit)
        {
            throw new InvalidOperationException(Resources.FormatObjectResultExecutor_MaxEnumerationExceeded(
                nameof(AsyncEnumerableReader),
                value.GetType()));
        }

        result.Add(item);
    }

    return result;
}

Il IAsyncEnumerable<>enumerata in una List<>utilizzando await foreach, che, quasi per definizione, non blocca un thread di richiesta. Come ha affermato Panagiotis Kanavos in un commento sull'OP, questa enumerazione viene eseguita per intero prima che una risposta venga inviata al client.