Come & # 8220; sicuro & # 8221; sono i tipi anonimi e la riflessione insieme?

Question

Suppongo che questo potrebbe anche essere chiesto per quanto tempo il nome del tipo creato è collegato a un tipo anonimo. Ecco il problema:

Un blog aveva qualcosa del genere:

var anonymousMagic = new {test.UserName};

lblShowText.Text = lblShowText
                     .Text
                     .Format("{UserName}", test);

Come una sorta di lista dei desideri e un paio di modi per farlo. Essendo annoiato e avventuroso, ho iniziato a creare un metodo di estensione delle stringhe che potesse gestirlo:

var anonymousMagic = new {test.UserName, test.UserID};

lblShowText.Text = "{UserName} is user number {UserID}"
                     .FormatAdvanced(anonymousMagic);

Con l'idea che avrei ottenuto le informazioni sulla proprietà dal tipo anonimo e le avrei abbinate alle stringhe tra parentesi. Ora con le informazioni sulla proprietà arriva la riflessione, quindi vorrei salvare le informazioni sulla proprietà la prima volta che il tipo è arrivato in modo da non doverlo recuperare di nuovo. Quindi ho fatto qualcosa del genere:

    public static String FormatAdvanced(this String stringToFormat, Object source)
    {

        Dictionary<String, PropertyInfo> info;
        Type test; 
        String typeName;
        //
        currentType = source.GetType();
        typeName = currentType.Name;
        //
        //info list is a static list for the class holding this method
        if (infoList == null)
        {
            infoList = new Dictionary<String, Dictionary<String, PropertyInfo>>();
        }
        //
        if (infoList.ContainsKey(typeName))
        {
            info = infoList[typeName];
        }
        else
        {
            info = test.GetProperties()
                       .ToDictionary(item => item.Name);
            infoList.Add(typeName, info);
        }  
        //
        foreach (var propertyInfoPair in info)
        {
            String currentKey;
            String replacement;

            replacement = propertyInfoPair.Value.GetValue(source, null).ToString();
            currentKey = propertyInfoPair.Key;

            if (stringToFormat.Contains("{" + currentKey + "}"))
            {
                stringToFormat = stringToFormat
                                 .Replace("{" + currentKey + "}", replacement);
            }
        }  
        //
        return stringToFormat;
    }

Ora in fase di test, sembra mantenere il nome creato per il tipo anonimo in modo che la seconda volta non riesca a ottenere le informazioni sulla proprietà dal tipo ma dal dizionario.

Se più persone stanno colpendo questo metodo allo stesso tempo, funzionerà in una sessione come fassion; Vale a dire i nomi dei tipi saranno specifici per ogni istanza del programma? O sarebbe anche peggio di così? A che punto quel nome viene ridimensionato e sovrascritto?

Answer 1

Non lo fa mai. Il tipo viene generato in fase di compilazione e puoi considerarlo costante e unico per tutta la durata del dominio dell'app.

Metto in dubbio il valore di questa funzione. Il primo ovvio motivo è che non hai molte funzionalità del metodo Format sulla classe String (nessuna scappatoia tra parentesi, nessuna formattazione di valori tra parentesi, ecc., Ecc.)

Il secondo è che fondamentalmente collega la stringa di formato al tipo che viene passato, quindi non vengono scambiati facilmente. Se avessi due classi con lo stesso valore concettuale, ma con proprietà diverse che lo denominano, devo modificare la stringa del formato per visualizzarla con il metodo per compensare il fatto che il nome della proprietà sia incorporato nella stringa del formato.

Answer 2

I tipi anonimi vengono generati al momento della compilazione, quindi i nomi delle riflessioni dovrebbero essere statici purché non si ricompili nuovamente l'assembly.

C'è un post dettagliato qui che descrive i nomi, ma credo che quello che stai facendo sia sicuro.

Answer 3

Ho due cose da dire, ma questa non è davvero una risposta.

Prima di tutto, il dizionario non deve avere una chiave stringa; la chiave potrebbe essere il tipo effettivo. cioè potrebbe essere un Dictionary < Type, Dictionary < String, PropertyInfo > > . Sarebbe più veloce perché non devi ottenere il nome del tipo e meno soggetto a errori - cosa succede se invio quel metodo due tipi non anonimi con lo stesso nome ma spazi dei nomi diversi?

In secondo luogo, dovresti leggere i recenti post di blog su questo argomento. Contiene una piena implementazione di tale metodo.