Abrufen des Eigenschaftswerts aus einer Zeichenkette mittels Reflexion

Question

Ich versuche die Implementierung der Datentransformation mit Reflection 1 Beispiel in meinem Code.

Le site GetSourceValue Funktion hat einen Schalter, der verschiedene Typen vergleicht, aber ich möchte diese Typen und Eigenschaften entfernen und die GetSourceValue den Wert der Eigenschaft mit nur einer einzigen Zeichenkette als Parameter abrufen. Ich möchte eine Klasse und eine Eigenschaft in der Zeichenfolge übergeben und den Wert der Eigenschaft auflösen.

Ist dies möglich?

1 _{<a href="https://web.archive.org/web/20130815002453/http://msmvps.com/blogs/shahed/archive/2008/07/24/c-reflection-tips-data-transformation-using-reflection.aspx" rel="noreferrer">Webarchiv-Version des ursprünglichen Blogbeitrags</a>}

Answer 1

 public static object GetPropValue(object src, string propName)
 {
     return src.GetType().GetProperty(propName).GetValue(src, null);
 }

Natürlich müssen Sie noch die Validierung und andere Dinge hinzufügen, aber das ist das Wesentliche.

Answer 2

Wie wäre es mit so etwas wie diesem:

public static Object GetPropValue(this Object obj, String name) {
    foreach (String part in name.Split('.')) {
        if (obj == null) { return null; }

        Type type = obj.GetType();
        PropertyInfo info = type.GetProperty(part);
        if (info == null) { return null; }

        obj = info.GetValue(obj, null);
    }
    return obj;
}

public static T GetPropValue<T>(this Object obj, String name) {
    Object retval = GetPropValue(obj, name);
    if (retval == null) { return default(T); }

    // throws InvalidCastException if types are incompatible
    return (T) retval;
}

So können Sie mit einer einzigen Zeichenfolge in die Eigenschaften hinabsteigen, etwa so:

DateTime now = DateTime.Now;
int min = GetPropValue<int>(now, "TimeOfDay.Minutes");
int hrs = now.GetPropValue<int>("TimeOfDay.Hours");

Sie können diese Methoden entweder als statische Methoden oder als Erweiterungen verwenden.

Answer 3

Hinzufügen zu jeder Class :

public class Foo
{
    public object this[string propertyName]
    {
        get { return this.GetType().GetProperty(propertyName).GetValue(this, null); }
        set { this.GetType().GetProperty(propertyName).SetValue(this, value, null); }
    }

    public string Bar { get; set; }
}

Dann können Sie als verwenden:

Foo f = new Foo();
// Set
f["Bar"] = "asdf";
// Get
string s = (string)f["Bar"];

Answer 4

Wie wäre es mit der Verwendung des CallByName de la Microsoft.VisualBasic Namensraum ( Microsoft.VisualBasic.dll )? Es verwendet Reflexion, um Eigenschaften, Felder und Methoden von normalen Objekten, COM-Objekten und sogar dynamischen Objekten zu erhalten.

using Microsoft.VisualBasic;
using Microsoft.VisualBasic.CompilerServices;

und dann

Versioned.CallByName(this, "method/function/prop name", CallType.Get).ToString();

Answer 5

Tolle Antwort von jheddings . Ich würde es gerne verbessern, indem ich die Referenzierung von aggregierten Arrays oder Sammlungen von Objekten erlaube, so dass propertyName sein könnte property1.property2[X].property3 :

    public static object GetPropertyValue(object srcobj, string propertyName)
    {
        if (srcobj == null)
            return null;

        object obj = srcobj;

        // Split property name to parts (propertyName could be hierarchical, like obj.subobj.subobj.property
        string[] propertyNameParts = propertyName.Split('.');

        foreach (string propertyNamePart in propertyNameParts)
        {
            if (obj == null)    return null;

            // propertyNamePart could contain reference to specific 
            // element (by index) inside a collection
            if (!propertyNamePart.Contains("["))
            {
                PropertyInfo pi = obj.GetType().GetProperty(propertyNamePart);
                if (pi == null) return null;
                obj = pi.GetValue(obj, null);
            }
            else
            {   // propertyNamePart is areference to specific element 
                // (by index) inside a collection
                // like AggregatedCollection[123]
                //   get collection name and element index
                int indexStart = propertyNamePart.IndexOf("[")+1;
                string collectionPropertyName = propertyNamePart.Substring(0, indexStart-1);
                int collectionElementIndex = Int32.Parse(propertyNamePart.Substring(indexStart, propertyNamePart.Length-indexStart-1));
                //   get collection object
                PropertyInfo pi = obj.GetType().GetProperty(collectionPropertyName);
                if (pi == null) return null;
                object unknownCollection = pi.GetValue(obj, null);
                //   try to process the collection as array
                if (unknownCollection.GetType().IsArray)
                {
                    object[] collectionAsArray = unknownCollection as object[];
                    obj = collectionAsArray[collectionElementIndex];
                }
                else
                {
                    //   try to process the collection as IList
                    System.Collections.IList collectionAsList = unknownCollection as System.Collections.IList;
                    if (collectionAsList != null)
                    {
                        obj = collectionAsList[collectionElementIndex];
                    }
                    else
                    {
                        // ??? Unsupported collection type
                    }
                }
            }
        }

        return obj;
    }