Compilatore ha generato Cruft

Question

Sto tentando di recuperare fonte da un assieme utilizzando del Reg Porta riflettore. La fonte originale ha approfittato di diverse caratteristiche di C # 3.0 che ha reso un po 'difficile da recuperare. Per esempio qui è la fonte recuperato per un tipo anonimo. La prima cosa che salta fuori è il <> in dall'alto l'identificatore di classe. regole tipo di denominazione fase di esecuzione sono apparentemente più liberale di norme sull'orario di progettazione. Giusto. Una semplice ricerca e sostituzione risolverà questo. Quali altri manglings compilatore devo guardare fuori per e come faccio a trattare con loro?

[DebuggerDisplay(@"\{ OverrideType = {OverrideType}, EntityType = {EntityType} }", Type="<Anonymous Type>"), CompilerGenerated]
internal sealed class <>f__AnonymousType1<<OverrideType>j__TPar, <EntityType>j__TPar>
{
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly <EntityType>j__TPar <EntityType>i__Field;
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly <OverrideType>j__TPar <OverrideType>i__Field;

    [DebuggerHidden]
    public <>f__AnonymousType1(<OverrideType>j__TPar OverrideType, <EntityType>j__TPar EntityType)
    {
        this.<OverrideType>i__Field = OverrideType;
        this.<EntityType>i__Field = EntityType;
    }

    [DebuggerHidden]
    public override bool Equals(object value)
    {
        var type = value as <>f__AnonymousType1<<OverrideType>j__TPar, <EntityType>j__TPar>;
        return (((type != null) && EqualityComparer<> <<OverrideType>j__TPar>.Default.Equals(this.<OverrideType>i__Field, type.<OverrideType>i__Field)) && EqualityComparer<<EntityType>j__TPar>.Default.Equals(this.<EntityType>i__Field, type.<EntityType>i__Field));
    }

    [DebuggerHidden]
    public override int GetHashCode()
    {
        int num = -338316509;
        num = (-1521134295 * num) + EqualityComparer<<OverrideType>j__TPar>.Default.GetHashCode(this.<OverrideType>i__Field);
        return ((-1521134295 * num) + EqualityComparer<<EntityType>j__TPar>.Default.GetHashCode(this.<EntityType>i__Field));
    }

    [DebuggerHidden]
    public override string ToString()
    {
        StringBuilder builder = new StringBuilder();
        builder.Append("{ OverrideType = ");
        builder.Append(this.<OverrideType>i__Field);
        builder.Append(", EntityType = ");
        builder.Append(this.<EntityType>i__Field);
        builder.Append(" }");
        return builder.ToString();
    }

    public <EntityType>j__TPar EntityType
    {
        get
        {
            return this.<EntityType>i__Field;
        }
    }

    public <OverrideType>j__TPar OverrideType
    {
        get
        {
            return this.<OverrideType>i__Field;
        }
    }
}

Answer 1

Il termine spesso usato per i nomi con <> in essi sono nomi indicibili - perché non sono valide C #. Questo impedisce loro di scontrarsi con i nomi non generati dal compilatore, e vi impedisce di cercare di farvi riferimento in C #.

Alcune cose che possono causare loro:

• blocchi Iterator generano tipi nidificati per la loro attuazione.

• inizializzatori di array come ad esempio:

  int[] x = new int[] { 1, 2, 3 };
  

  genererà una classe <PrivateImplementationDetails>{...}. (Ma solo per alcuni tipi.)

• Le espressioni lambda possono creare nuovi metodi e nuovi tipi per implementare la logica, e le variabili statiche utilizzate per i delegati della cache e alberi di espressione, ove possibile

• Se si compila con le informazioni di debug attivata, inizializzatori raccolta e di oggetti come ad esempio:

  List<string> list = new List<string> { "hello", "there" }`)
  Button button = new Button { Text = "Hi" };
  

  causerà variabili locali con nomi indicibili da generare. (Sono abituati a tenere il valore temporaneo, mentre le proprietà vengono assegnati e aggiunti elementi, prima della cessione alla verifica della variabile reale.)

• codice dinamico in C # 4 crea ogni genere di cose strane e meravigliose

Se si attiva il livello di "ottimizzazione" in Reflector (Visualizza / Opzioni / Disassembler) sarà normalmente fare del suo meglio per darvi qualcosa come il codice sorgente originale - girare l'ottimizzazione off per un'esperienza interessante:)

Answer 2

Lambda che le variabili di cattura si traducono in chiusure rappresentate da simili tipi creati automaticamente.

Answer 3

Utilizzo di istruzioni anche tradursi in una piccola trasformazione del codice, così come la parola chiave Static in VB.Net.