Domanda

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;
        }
    }
}
È stato utile?

Soluzione

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:)

Altri suggerimenti

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

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

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top