Utilizzando vincoli generici con i tipi di valore

Question

sto sperimentando con metodi di estensione fluente.

Ho il seguente metodo di estensione semplice per eseguire un cast di sicurezza.

 public static T As<T>(this Object source) 
     where T : class 
    { 
     return source as T; 
    } 

Questo funzionava bene, ma quando ho cercato di rendere intuitivo da usare valuetypes con un sovraccarico

 public static T As<T>(this ValueType source) 
     where T : struct 
    { 
     return (T)source; 
    } 

ho incontrato problemi. La logica di risoluzione del metodo sceglie sempre il primo metodo sopra riportato e fornisce un errore di sintassi (accurato) che la struct non è una classe.

C'è un modo per gestire quanto sopra, o devo seguire il percorso di rimozione del vincolo durante il test e la gestione di tutti i tipi nello stesso metodo?

Edit ====: per rispondere alle domande ====

sto compilando questo contro il framework 3.5. Non sto davvero cercando di realizzare qualcosa in particolare; questo è solo un esperimento con quanto sopra. Il mio interesse è stato commosso e ho buttato un po 'di codice.

Non sono particolarmente interessato a rimanere un cast "sicuro". È così che è iniziato, e può essere tenuto al sicuro con default() - ma questo non è veramente il punto focale della domanda e del codice per garantire che la "sicurezza" sia oscura.

Per quanto riguarda l'espressività, n. value.As<int>() non è più espressivo di (int)value; ma perché l'utente del metodo deve 'solo sapere' funziona solo con i tipi di riferimento? Il mio tentativo di farlo era più sul comportamento previsto del metodo che sulla scrittura espressiva.

Il frammento di codice value.As<DateTime>() restituisce l'errore "Il tipo 'System.DateTime' deve essere un tipo di riferimento per utilizzarlo come parametro 'T' nel tipo generico o nel metodo .... As (oggetto)" . Dal messaggio di errore vedo che si sta risolvendo a utilizzare il metodo top sopra poiché è quello che richiede il tipo di riferimento.

Answer 1

In .NET 4, il secondo di sovraccarico viene scelto in base al codice di esempio. (Anche solo testati contro .NET 3.5, stesso risultato.)

int myInt = 1; 
long myLong = myInt.As<long>(); // chooses ValueType version 

Tuttavia, questo ci ottiene solo per la scena della prossima crisi. Il (T)source; genera un'eccezione di cast non valida. Si potrebbe aggirare che scrivendo il metodo

public static T As<T>(this ValueType source) 
    where T : struct 
{ 
    return (T)Convert.ChangeType(source, typeof(T)); 
} 

Tuttavia, mi chiedo cosa si sta effettivamente cercando di raggiungere, come io non vedo il beneficio immediato. (E del resto, questo non è sicura come la versione source as T oggetto.) Per esempio, come è

long myLong = myInt.As<long>(); 

Qualsiasi più espressivo o più facile da usare rispetto

long myLong = (long)myInt;