Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C#

Delegati Func con tupla e accumulatore e convalida della dimensione

Un delegato segnala l’esito della conversione, un altro aggiorna l’accumulatore e una dimensione fuori dall’intervallo consentito provoca un’eccezione.

Versione: C# 12 and .NET 8; later runtimes may add compatible features

Sintassi

System.Func<TSource, (bool Success, TResult Value)> convert;
System.Func<TAcc, T, TAcc> accumulate;

if (size < 0 || size > source.Count)
    throw new System.ArgumentOutOfRangeException(nameof(size), size, "Size must be between zero and the source count.");

Func<TSource,(bool,TResult)> è un delegato dello spazio dei nomi System. Accetta un argomento di tipo TSource e restituisce un solo valore: una tupla del tipo valore System.ValueTuple<bool,TResult>, non due parametri out. I nomi dei campi, come Success e Value, sono facoltativi; si può decostruire il risultato con var (success, value). Il significato del flag fa parte del contratto del delegato: qui false indica che il valore va ignorato, mentre true permette di usarlo anche se coincide con il valore predefinito del tipo.

Func<TAcc,T,TAcc> è un altro tipo di delegato di System. Riceve l’accumulatore corrente di tipo TAcc e un elemento di tipo T, quindi restituisce il nuovo accumulatore di tipo TAcc. L’ultimo argomento di tipo di Func è il tipo restituito. In FoldPrefix, T è il tipo del risultato della conversione (TResult nella prima notazione). Il metodo parte da seed, visita nell’ordine i primi size elementi e aggiorna l’accumulatore solo quando la conversione riesce. Anche gli elementi scartati contano ai fini di size.

FoldPrefix è un metodo di esempio, non un’API di .NET. La dimensione ammessa va da 0 a source.Count, estremi inclusi. Con zero restituisce seed senza invocare i delegati. Se size < 0 || size > source.Count, genera System.ArgumentOutOfRangeException prima di accedere a un elemento per indice o invocare un delegato. Il costruttore a tre argomenti riceve, nell’ordine, il nome del parametro (nameof(size)), il valore non valido (size) e un messaggio che descrive l’intervallo. Nome e valore si leggono tramite ParamName e ActualValue.

Esempi

using System;
using System.Collections.Generic;
using System.Globalization;

string[] items = { "2", "bad", "3", "100" };
Func<string, (bool Success, int Value)> convert = text =>
{
    bool success = int.TryParse(text, NumberStyles.Integer,
        CultureInfo.InvariantCulture, out int value);
    return (success, value);
};
Func<int, int, int> accumulate = (sum, value) => sum + value;

Console.WriteLine(FormattableString.Invariant($"size 3: {FoldPrefix(items, 3, 10, convert, accumulate)}"));
Console.WriteLine(FormattableString.Invariant($"size 0: {FoldPrefix(items, 0, 10, convert, accumulate)}"));

try
{
    FoldPrefix(items, 5, 10, convert, accumulate);
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine(FormattableString.Invariant($"out of range: {ex.ParamName}={ex.ActualValue}"));
}

static TAcc FoldPrefix<TSource, T, TAcc>(
    IReadOnlyList<TSource> source, int size, TAcc seed,
    Func<TSource, (bool Success, T Value)> convert,
    Func<TAcc, T, TAcc> accumulate)
{
    ArgumentNullException.ThrowIfNull(source);
    ArgumentNullException.ThrowIfNull(convert);
    ArgumentNullException.ThrowIfNull(accumulate);

    if (size < 0 || size > source.Count)
        throw new ArgumentOutOfRangeException(nameof(size), size,
            "Size must be between zero and the source count.");

    TAcc acc = seed;
    for (int i = 0; i < size; i++)
    {
        var (success, value) = convert(source[i]);
        if (success)
            acc = accumulate(acc, value);
    }
    return acc;
}

Risultato

size 3: 15
size 0: 10
out of range: size=5

Esempio da console per C# 12 e .NET 8: la dimensione 3 dà 15 (10 + 2 + 3), perché `bad` viene ignorato e `100` è fuori dal prefisso. La dimensione 0 dà 10. La dimensione 5 non è valida per quattro elementi; il programma stampa il nome del parametro e il suo valore, non il messaggio dell’eccezione.

Lezioni correlate

  • C# · Lezione 29 · Avanzato · Versione: 3

Fonti