Funzioni di supporto per la conversione sicura da stringhe

Question

Di nuovo in VB6, ho scritto alcune funzioni che mi permetterebbero di programmare senza preoccuparmi della differenza tra null e '' per le stringhe, null e 0 per i numeri, ecc. Nulla uccide di più la mia produttività durante la codifica che dover aggiungere un codice caso speciale per gestire i dati che potrebbero causare errori irrilevanti; 9999/10000 se qualcosa che sto usando come numero è nullo, allora lo tratto come 0.

Ora sono in C #, e la differenza tra VB6 e C # 2005 è piuttosto ampia ... quindi non so davvero da dove iniziare a scrivere il mio nuovo set di funzioni di supporto, o se ho bisogno di farlo affatto.

Quindi, ho bisogno di scrivere una funzione che accetti una stringa, un campo di database, un modulo di richiesta / campo querysting, ???, e quindi fare tutto ciò che potrebbe fare per trasformarlo in un doppio e restituirlo a la procedura di chiamata.

Dovrei anche fare questo per cortometraggi, int16, int32, long, qualsiasi altra cosa di cui mi possa interessare.

Quindi lo farei per le stringhe. E date.

È una ricerca utile? C'è qualcosa nel framework o C # che posso usare invece? Desidero davvero qualcosa che mi consenta di utilizzare i dati in linea per chiamare altre funzioni e non dover creare variabili temporanee, ecc.

Answer 1

Esistono scadenze di funzioni di conversione integrate. Ma ... non sono sicuro che nessuno di loro faccia esattamente quello che vuoi. In genere, i metodi .NET sono errati quando vengono inviati input non validi e generano un'eccezione.

Fortunatamente, puoi facilmente scrivere un metodo di utilità per convertire una rappresentazione in formato stringa di un valore numerico, una stringa vuota vuota o una stringa nulla in qualsiasi tipo di output:

public static T SafeConvert<T>(string s, T defaultValue)
{
    if ( string.IsNullOrEmpty(s) )
        return defaultValue;
    return (T)Convert.ChangeType(s, typeof(T));
}

Usa:

SafeConvert(null, 0.0) == 0.0;
SafeConvert("", 0.0) == 0.0;
SafeConvert("0", 0.0) == 0.0;

Questo metodo generico prende il suo tipo restituito dal tipo del secondo argomento, che viene usato come valore predefinito quando la stringa passata è nulla o vuota. Passa 0 e otterrai un In32 . Passa 0L , Int64 . E così via ...

Answer 2

In C # la maggior parte dei tipi di dati non è nullable (numeri, date, ecc.), solo le stringhe sono nullable. Se stai ricevendo dati da un DB, probabilmente lavorerai con Nullable o la sua versione sintattica, int ?, double ?, DateTime ?, ecc.

Tutti i nullable hanno un metodo che ti consente di ottenere il loro valore effettivo o valore predefinito se sono nulli. Ciò dovrebbe aiutarti a evitare di creare tali funzioni.

Per quanto riguarda le stringhe, hai la funzione String.IsNullOrEmpty (str).

Puoi anche aggiungere metodi di estensione se vuoi qualcosa di speciale funzionalità non disponibile. Si noti che i metodi di estensione possono essere applicati a valori nulli, purché vengano gestiti nel codice. Ad esempio:

public static string ValueOrDefault(this string str) 
{
     if (String.IsNullOrEmpty(str)) return MY_DEFAULT_VALUE;
     else return str;
}

Answer 3

Esiste una classe chiamata Converti nella libreria .NET. Ha funzioni che ti consentono di convertire qualsiasi cosa tu abbia bisogno da qualsiasi tipo di base e da alcune delle classi comuni (come DateTime.)

Funziona sostanzialmente come Convert.ToInt32 (val);

EDIT: ho davvero bisogno di imparare a leggere tutte le parole. Non ho preso la preoccupazione per null ... c'è un operatore per questo. Puoi usare il ?? per verificare la presenza di null e fornire comunque un valore predefinito in modo che possa funzionare.

Potresti anche voler esaminare LINQ, gestisce molto quel tipo di mappatura per te.

Answer 4

Penso che sia simile a @ Shog9. Aggiungo solo un tentativo di prova per gestire l'input insolito dell'utente. Mando il tipo in cui voglio convertire l'input e prendo l'input come oggetto.

public static class SafeConverter
{
   public static T SafeConvert<T>(object input, T defaultValue)
   {
       if (input == null)
          return defaultValue; //default(T);

       T result;
       try
       {
           result = (T)Convert.ChangeType(input.ToString(), typeof(T));
       }
       catch
       {
          result = defaultValue; //default(T);
       }
       return result;
   }
} 

Ora chiamali come sotto

SafeConverter.SafeConvert<ushort>(null, 0);
SafeConverter.SafeConvert<ushort>("", 0);
SafeConverter.SafeConvert<ushort>("null", 0);
SafeConverter.SafeConvert<ushort>("-1", 0);
SafeConverter.SafeConvert<ushort>("6", 0);
SafeConverter.SafeConvert<ushort>(-1, 0);
SafeConverter.SafeConvert<ushort>(0, 0);
SafeConverter.SafeConvert<ushort>(1, 0);
SafeConverter.SafeConvert<ushort>(9, 0);