Diciamo che ho un tale codice (e il suo significato è come in C #):
class Foo<T>
{
public T my_field;
}
e più tardi nel codice che ho:
var foo = new Foo<int>();
foo.my_field = 5;
Il mio problema inizia con Foo<int> . Quello che faccio attualmente è prendere tipo Foo<T> e mappare T -> int e clonare la superficie di quel tipo. Superficie perché salta le espressioni di init, i corpi metodo / proprietà, ma ciononostante creo qualcosa del genere al volo:
class Foo<int>
{
public int my_field;
}
e poi continua come sarebbe il solito tipo. La cosa buona è che funziona, ma la cosa brutta è che funziona lentamente - il profiler non esita a sottolineare che è il collo di bottiglia.
L'altra idea che ho sta usando qualcosa come una "vista" che consisterebbe nel riferimento al tipo generico (qui Foo<T> ) e alla mappatura (qui T -> int ) e quindi utilizzandolo ogni volta che faccio riferimento a un'istanza di tipo generico . In caso di foo , passerei attraverso tale vista a un campo, otterrei il suo tipo T e "filtrerò" nuovamente attraverso la vista per ottenere finalmente il risultato: int . Vorrei evitare l'approccio di prova e errore in modo ...
La mia domanda è come le istanze di tipo generico vengono gestite nel compilatore (non in runtime)? Intendo per davvero: -).