async TryParse (...) modello

Question

Esistono molti metodi comuni bool TryXXX(out T result) in .NET BCL, l'essere più popolare, probabilmente, int.TryParse(...).

Vorrei implementare un metodo asyncTryXXX(). Ovviamente, non posso usare i parametri out.

Esiste uno schema stabilito per questo?

Più precisamente, ho bisogno di scaricare e analizzare un file. È possibile che il file non esista.

Questo è quello che mi è venuto in mente finora:

public async Task<DownloadResult> TryDownloadAndParse(string fileUri) 
{ 
    try 
    { 
     result = await DownloadAndParse(fileUri); //defined elsewhere 
     return new DownloadResult {IsFound = true, Value = result} 
    } 
    catch (DownloadNotFoundException ex) 
    { 
     return new DownloadResult {IsFound = false, Value = null} 
    } 
    //let any other exception pass 
} 

public struct DownloadResult 
{ 
    public bool IsFound { get; set; } 

    public ParsedFile Value { get; set; } 
} 

Answer 1

mi è venuta in mente le seguenti definizioni. I parametri defaultValue sono principalmente in grado di sovraccaricare il metodo TryGet, poiché i vincoli generici non fanno parte della firma di un metodo, ciò che rende il metodo univoco quando si decide quale metodo chiamare (ad esempio, anche il tipo restituito non fa parte di la firma).

public async Task<T> TryGet<T>(Func<Task<T>> func, T defaultValue = null) where T : class 
{ 
    try 
    { 
     return await func(); 
    } 
    catch (ArgumentException) 
    { 
     return defaultValue; 
    } 
    catch (FormatException) 
    { 
     return defaultValue; 
    } 
    catch (OverflowException) 
    { 
     return defaultValue; 
    } 
} 

public async Task<Nullable<T>> TryGet<T>(Func<Task<T>> func, Nullable<T> defaultValue = null) where T : struct 
{ 
    try 
    { 
     return await func(); 
    } 
    catch (ArgumentException) 
    { 
     return defaultValue; 
    } 
    catch (FormatException) 
    { 
     return defaultValue; 
    } 
    catch (OverflowException) 
    { 
     return defaultValue; 
    } 
} 

È necessario esaminare la gestione delle eccezioni, questo esempio gestisce le eccezioni di analisi comuni. Potrebbe essere più sensato reagire ad altre eccezioni, come InvalidOperationException e NotSupportedException, probabilmente i tipi di eccezioni più utilizzati sul framework stesso (non necessariamente quelli generati più comunemente).

Un altro approccio consiste nel rilanciare eccezioni critiche, ad esempio ThreadAbortException e avere una clausola catch-all semplice che restituisce il valore predefinito. Tuttavia, questo nasconderà ogni eccezione non ritenuta critica, non importa quanto sia grave.

Come tale, e poiché il lancio di eccezioni è un'operazione costosa, è Parse che viene solitamente definito in termini di TryParse. Quindi il tuo TryGet dovrebbe avere un contratto, ad es. trattare con OperationCanceledException, che include TaskCanceledException e nient'altro.

Infine, è necessario denominarlo TryGetAsync, seguendo la convenzione del suffisso Asincrono. ^[1][2]

Answer 2

Una delle possibili decisioni è un array di ParsedFile, contenente 0 o 1 elemento.

public async Task<ParsedFile[]> TryDownloadAndParse(string fileUri) 
{ 
    try 
    { 
     return new[] { await DownloadAndParse(fileUri) }; 
    } 
    catch (DownloadNotFoundException ex) 
    { 
     return new ParsedFile[0]; 
    } 
} 

Ora è possibile controllare il risultato:

. . . 

var parsedFiles = await TryDownloadAndParse(url); 
if (parsedFiles.Any()) 
{ 
    var parsedFile = parsedFiles.Single(); 
    // more processing 
} 

. . . 

Se si desidera chiamare void metodo, è possibile utilizzare ?. operatore:

var parsedFiles = await TryDownloadAndParse(url); 
parsedFiles.SingleOrDefault()?.DoVeryImportantWorkWithoutResult(); 

UPDATE

In Azure puoi usare ConditionalValue<TValue> class.