Ho un lettore di configurazione personalizzato che svolge varie funzioni su .NET CloudConfigurationManager e ConfigurationManager implementazioni, come la memorizzazione nella cache, la conversione del tipo, ecc.

Il seguente metodo viene utilizzato per recuperare un elemento di configurazione:

public T GetSetting<T>(string key)
{
    string value = GetSetting(key);

    return (T)Convert.ChangeType(value, typeof(T), CultureInfo.InvariantCulture);
}

Ci sono alcuni punti di errore per i quali voglio aggiungere la gestione delle eccezioni corretta.

GetSetting<T> con gestione delle eccezioni:

public T GetSetting<T>(string key)
{
    // If the key is null or empty
    if (String.IsNullOrWhiteSpace(key))
    {
        throw new ArgumentNullException(String.Format("Configuration value with key '{0}' cannot be null or empty", key));
    }

    string value = GetSetting(key);

    // If the value does not exist in the underlying configs
    if(value == null)
    {
        throw new ArgumentOutOfRangeExcetion(String.Format("Configuration value with key '{0}' does not exist", key));
    }

    try
    {
        return (T)Convert.ChangeType(value, typeof(T), CultureInfo.InvariantCulture);
    }
    catch(InvalidCastException ex)
    {
        throw new ArgumentOutOfRangeException(String.Format("Configuration value with key '{0}' could not be converted: Conversion not supported.", key), ex);
    }
    catch (FormatException ex)
    {
        throw new ArgumentOutOfRangeException(String.Format("Configuration value with key '{0}' could not be converted: Format error.", key), ex);
    }
}

Le mie domande e i miei dubbi:

Se la chiave è null o vuota:

È accettabile lanciare un ArgumentNullException quando il parametro stringa non è solo nullo, ma anche vuoto? Forse un ArgumentException è migliore in quanto si tratta di un problema più generale rispetto al controllo di null .

Se il valore non esiste nelle configurazioni di base:

Un ArgumentOutOfRangeException viene generalmente utilizzato per un indice che non esiste nella raccolta basata su elenchi o dizionari. Si applica qui? Le configurazioni sono essenzialmente dizionari di coppie chiave valore.

L'idea è che il metodo può solo restituire null, ma per questo motivo ho fornito un metodo HasSetting(string) . Secondo me, più è esplicito, meglio è. Il controllo di null nel codice client richiede la comprensione implicita della funzionalità incapsulata, che può essere spesso utilizzata in modo errato, travisata e fraintesa.

Se l'analisi di T non riesce per qualsiasi motivo:

Questo è il difficile. Qual è il miglior tipo di eccezione per incapsulare le eccezioni di "conversione"? Devo lasciare che le eccezioni sottostanti da Convert.ChangeType() siano esplosive?

% eccezione di overflow diConvert.ChangeType():

Non vedo alcun motivo per gestire il OverflowException in Convert.ChangeType() . Lascerò solo questo tiro.

Per ragioni di riferimento, queste sono le eccezioni generate da Convert.ChangeType() :

// Exceptions:
//   System.InvalidCastException:
//     This conversion is not supported. -or-value is null and conversionType is
//     a value type.-or-value does not implement the System.IConvertible interface.
//
//   System.FormatException:
//     value is not in a format for conversionType recognized by provider.
//
//   System.OverflowException:
//     value represents a number that is out of the range of conversionType.
//
//   System.ArgumentNullException:
//     conversionType is null.