Perché il codice generico dovrebbe compilare senza vincolare T?

Question

Il seguente frammento di codice viene estratto dal Esempio 10-11 (p 343). Da di programmazione C# 5.0:

public static T[] Select<T>(this CultureInfo[] cultures, 
          Func<CultureInfo, T> map) 
{ 
    var result = new T[cultures.Length]; 
    for (int i = 0; i < cultures.Length; ++i) 
    { 
     result[i] = map(cultures[i]); 
    } 
    return result; 
} 

io non riesco a capire come si potrebbe ottenere compilato senza esporre alcuna informazione su T da applicando i vincoli su di esso. In particolare, in che modo il compilatore può sapere quanti byte allocare per l'array, dato che T potrebbe non essere un tipo di riferimento, ma un tipo di valore (ad esempio, struct)? Inoltre, la semantica dell'attività di assegnazione result[i] = map(cultures[i]) sembra dipendere dal fatto che T sia un tipo di riferimento o un tipo di valore.

Answer 1

Penso che la chiave qui per capire questo è meglio espresso come segue:

In primo luogo, al momento della compilazione, viene creato un metodo generico, che è semplicemente la versione IL di quello che hai scritto lì nell'origine . È typesable (map restituisce un T e le celle di matrice sono di tipo T, quindi non c'è alcun problema lì) e tutto è a posto.

Ora, in fase di esecuzione, (concettualmente almeno) la prima volta che si utilizza Select<string>, ad esempio, il compilatore JIT a quel punto crea un nuovo metodo.Chiamiamo questo metodo Select__string (in realtà è in genere chiamato qualcosa come Select'string Penso, ma non voglio che tu pensi che sia importante ai fini di questa spiegazione). In questo nuovo metodo, tutte le istanze di T vengono sostituiti con string, e così, naturalmente, in quel metodo compilato tutto è facilmente elaborato - assegnazioni, l'allocazione dimensione della matrice, ecc

Successiva Ti Select<int> da qualche altra parte. Il compilatore JIT ora crea un metodo completamente nuovo che chiameremo Select__int. E ancora, tutte le istanze di T vengono sostituite con int, e così di nuovo, la semantica della dimensione degli array e dell'assegnazione vengono gestite facilmente.

Lo stesso vale per i tipi generici. Quando vengono effettivamente utilizzati, List<string> e List<int> sono due tipi completamente separati. Questo è il motivo per cui i generici .net sono così facili da scrivere e usare.

Se questo non è chiaro, puoi dare un esempio di cosa specificamente, nel tuo codice sopra, pensi che avrebbe ancora bisogno di essere conosciuto o limitato in fase di compilazione?

Answer 2

Non esiste alcuna dipendenza tra CultureInfo e T di sorta. Tutti gli T sono ugualmente validi, dal momento che gestisci la "conversione" utilizzando il tuo Func<CultureInfo, T> personalizzato.

Penso che tu sia confuso su come i generici funzionano in C#. Non sono una funzionalità di compilazione (come in Java), sopravvivono fino al runtime. Solo quando hai effettivamente bisogno di un tipo generico reificato è quel tipo compilato, ea quel punto sa già cosa sia T.

Questo è ovviamente uno dei motivi per cui C# non ha Java List<?>. Non esiste un "tipo generico comune", si sta solo "ritardando" la reificazione dei tipi - una volta che si dispone di List<string> e List<int>, i due sono tipi completamente separati, e solo la riflessione ti dice che provengono dallo stesso tipo generico.

Answer 3

In particolare, come potrebbe il compilatore sapere quanti byte da allocare per la matrice,

non lo fa. Non c'è bisogno che il compilatore lo sappia.

Ma supponiamo che l'istruzione newarr abbia bisogno di avere una dimensione in byte. Quindi il compilatore potrebbe semplicemente lasciare che la moltiplicazione della dimensione del tipo di elemento e la lunghezza dell'array vengano eseguite in fase di esecuzione.

Inoltre, la semantica dell'operazione di assegnazione result[i] = map(cultures[i]) sembra dipendere dal fatto T è un tipo di riferimento o un tipo di valore.

Non dipende da quello. Indipendentemente dal tipo, viene eseguita una copia esatta di qualsiasi cosa restituisca lo map. Se si tratta di un tipo di valore, significa che il valore viene copiato. Se si tratta di un tipo di riferimento, significa che il riferimento viene copiato.