Un modo più elegante di scoprire se posso convertire un valore in un certo tipo

Question

Sto lavorando con qualche codice legacy in questo momento che di solito utilizzava try + catch in combinazione con Convert.ToDecimal(someString) (ad esempio) per provare e convertire stringhe in decimali . Per alcuni motivi devo usare l'impostazione che - quando si esegue il debug - mi fermo ad ogni eccezione lanciata (non solo all'utente non gestita) e quindi questo è diventato fastidioso e l'ho modificato per utilizzare i metodi TryParse ogni volta che è possibile.

momento sto facendo una situazione in cui c'è un valore e un obiettivo objectType, e tutto quello che voglio sapere è se posso convertire il valore nel tipo di destinazione. In questo momento questo è fatto come segue:

try 
{ 
    Convert.ChangeType(val, targetType); 
} 
catch 
{ 
    // Do something else 
} 

Il risultato effettivo non è importante e non viene utilizzato ulteriormente.

Mentre questo codice funziona in questo momento, come ho detto, diventa un po 'fastidioso e quindi mi chiedo: C'è un altro modo di fare quanto sopra senza dover rilevare un'eccezione?

ho pensato a qualcosa di simile a IsAssignableFrom su un Type, ma questo non sembra essere applicabile nel mio caso (non voglio assegnare, voglio sapere se esplicitamente conversione è possibile).

Answer 1

Se vuoi dire la fusione, che è possibile utilizzare is parole chiave come:

object someObject = GetSomeObject(); 
if (someObject is string) 
{ 
    .. 
} 

Ma nota, che fusione e Convert.ChangeType non sono la stessa. Ad esempio, non è possibile lanciare una stringa in un int:

string numberString = "15"; 
int number = (int)numberString; 

ma è possibile utilizzare ChangeType per esso:

string numberString = "15"; 
int number = (int)Convert.ChangeType(numberString, typeof(int)); 

EDIT:

Se è necessario testare una variabile per essere convertibile in un tipo specifico, quindi perché non solo avvolgere try-catch con Convert.ChangeType in un metodo di prova:

public bool IsConvertibleTo<T>(object value) 
{ 
    try 
    { 
     T convertedValue = (T)Convert.ChangeType(value, typeof(T)); 
     return true; 
    } 
    catch (InvalidCastException) 
    { 
     return false; 
    } 
    catch (FormatException) 
    { 
     return false; 
    } 
    catch (OverflowException) 
    { 
     return false; 
    } 
} 

Answer 2

Se si desidera controllare il tipo di val, è necessario utilizzare parole chiave is come questo,

if (val is targetType) { 
    ... 
} 

Se si desidera convertire val a digitare targetType, è necessario utilizzare parole chiave as come questo,

targetType result = val as targetType; 

if (result != null) { 
    ... 
} 

Entrambi non lanciano un'eccezione!

Link: https://msdn.microsoft.com/zh-cn/library/cscsdfbt.aspx

Answer 3

ti darò una soluzione per eccezioni "nascondere". A volte è necessario rilevare un'eccezione e come hai detto è fastidioso perché il debugger si fermerà su ogni eccezione.Lo so, ma c'è un modo di fare che:

[DebuggerStepThrough] 
public bool CanChangeType(this object instance, Type targetType) 
{ 
    try 
    { 
    Convert.ChangeType(val, targetType); 
    return true; 
    } 
    catch 
    { 
    return false; 
    } 
} 

Il trucco è il -attribute DebuggerStepThrough.

Ma tieni presente che non sarai mai in grado di eseguire il debug in tale metodo. Non c'è correzione di bug senza rimuovere l'attributo. Sapendo che un metodo dovrebbe essere breve - molto breve e ovviamente dovrebbe essere libero da tutti gli errori.

Ho gli stessi problemi con le classi Udp che generano un'eccezione alla chiusura. L'estrazione di questo codice breve in un metodo separato che non contiene errori funziona correttamente.

Answer 4

L'ipotesi iniziale è giusta.

public static bool CanChangeType(Type type) 
    { 
     return typeof (IConvertible).IsAssignableFrom(type); 
    } 

è il modo giusto per controllare per tipo se Convert.ChangeType funzionerà o meno (come il messaggio di eccezione di solito indica). Non sei sicuro del motivo per cui sei contrario a questo metodo a causa del "Assegna" nel suo nome. Sta solo eseguendo alcuni controlli sul tipo. A parte questo, in realtà non esegue alcun assegnamento.