Wie verwende ich Reflexionseigenschaften erhalten explizit eine Schnittstelle zu implementieren?

StackOverflow https://stackoverflow.com/questions/278997

Frage

Genauer gesagt, wenn ich: 

public class TempClass : TempInterface
{

    int TempInterface.TempProperty
    {
        get;
        set;
    }
    int TempInterface.TempProperty2
    {
        get;
        set;
    }

    public int TempProperty
    {
        get;
        set;
    }
}

public interface TempInterface
{
    int TempProperty
    {
        get;
        set;
    }
    int TempProperty2
    {
        get;
        set;
    }
}

Wie verwende ich die Reflexion propertyInfos alle Objekte der Umsetzung TempInterface explizit zu bekommen?

Danke.

War es hilfreich?

Lösung 5

Ich hatte Jacob Carpenter Antwort zu ändern, aber es funktioniert gut. nobugz ist auch funktioniert, aber Jacobs ist kompakter. 

var explicitProperties =
from method in typeof(TempClass).GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
where method.IsFinal && method.IsPrivate
select method;

Andere Tipps

Ich denke, die Klasse Sie suchen, ist System.Reflection.InterfaceMapping. 

Type ifaceType = typeof(TempInterface);
Type tempType = typeof(TempClass);
InterfaceMapping map = tempType.GetInterfaceMap(ifaceType);
for (int i = 0; i < map.InterfaceMethods.Length; i++)
{
    MethodInfo ifaceMethod = map.InterfaceMethods[i];
    MethodInfo targetMethod = map.TargetMethods[i];
    Debug.WriteLine(String.Format("{0} maps to {1}", ifaceMethod, targetMethod));
}

Die Eigenschaft Getter und Setter einer explizit implementierte Schnittstelle Eigenschaft hat eine ungewöhnliche Eigenschaft. Es ist IsFinal Eigenschaft ist wahr, auch wenn sie kein Mitglied einer versiegelten Klasse. Versuchen Sie diesen Code meine Behauptung zu überprüfen: 

  foreach (AssemblyName name in Assembly.GetEntryAssembly().GetReferencedAssemblies()) {
    Assembly asm = Assembly.Load(name);
    foreach (Type t in asm.GetTypes()) {
      if (t.IsAbstract) continue;
      foreach (MethodInfo mi in t.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)) {
        int dot = mi.Name.LastIndexOf('.');
        string s = mi.Name.Substring(dot + 1);
        if (!s.StartsWith("get_") && !s.StartsWith("set_")) continue;
        if (mi.IsFinal)
          Console.WriteLine(mi.Name);
      }
    }
  }

Hier ist eine modifizierte Lösung auf der in dieses Blog-Post : 

var explicitProperties =
    from prop in typeof(TempClass).GetProperties(
        BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
    let getAccessor = prop.GetGetMethod(true)
    where getAccessor.IsFinal && getAccessor.IsPrivate
    select prop;

foreach (var p in explicitProperties)
    Console.WriteLine(p.Name);

Aufbauend auf der

Es ist zu komplex. Sie haben über die Methoden / Eigenschaften der Schnittstelle zu reflektieren, ob sie in der Klasse Typ existieren, und vergleichen Sie sie, um zu sehen, ob sie die „gleich“ sind, wenn sie existieren.

Wenn etwas in der Schnittstelle ist aber nicht der Typ, Sie testen, es ist eine explizite Implementierung. Wenn es in den beiden ist, aber anders zwischen den beiden, es ist eine explizite Schnittstelle.

Jakobs Code fehlt ein Filter: 

        var props = typeof(TempClass).GetInterfaces().Where(i => i.Name=="TempInterface").SelectMany(i => i.GetProperties());
        foreach (var prop in props)
            Console.WriteLine(prop);

Dies scheint ein wenig schmerzhaft ohne ersichtlichen Grund!

Meine Lösung ist für den Fall, dass Sie den Namen der Eigenschaft wissen Sie suchen und ist recht einfach.

Ich habe eine Klasse für die Herstellung von Reflexion etwas einfacher, dass ich musste einfach diesen Fall in der: 

public class PropertyInfoWrapper
{
    private readonly object _parent;
    private readonly PropertyInfo _property;

    public PropertyInfoWrapper(object parent, string propertyToChange)
    {
        var type = parent.GetType();
        var privateProperties= type.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance);

        var property = type.GetProperty(propertyToChange) ??
                       privateProperties.FirstOrDefault(p => UnQualifiedNameFor(p) == propertyName);

        if (property == null)
            throw new Exception(string.Format("cant find property |{0}|", propertyToChange));

        _parent = parent;
        _property = property;
    }

    private static string UnQualifiedNameFor(PropertyInfo p)
    {
        return p.Name.Split('.').Last();
    }

    public object Value
    {
        get { return _property.GetValue(_parent, null); }
        set { _property.SetValue(_parent, value, null); }
    }
}

Sie kippe tun nur == auf Namen, weil explizit implementiert Eigenschaften voll qualifizierten Namen haben.

GetProperties muss sowohl die Suche Fahnen auf private Eigenschaften erhalten.

Eine einfache Hilfsklasse, die helfen könnten: 

public class InterfacesPropertiesMap
{
    private readonly Dictionary<Type, PropertyInfo[]> map;

    public InterfacesPropertiesMap(Type type)
    {
        this.Interfaces = type.GetInterfaces();
        var properties = type.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);

        this.map = new Dictionary<Type, PropertyInfo[]>(this.Interfaces.Length);

        foreach (var intr in this.Interfaces)
        {
            var interfaceMap = type.GetInterfaceMap(intr);
            this.map.Add(intr, properties.Where(p => interfaceMap.TargetMethods
                                                    .Any(t => t == p.GetGetMethod(true) ||
                                                              t == p.GetSetMethod(true)))
                                         .Distinct().ToArray());
        }
    }

    public Type[] Interfaces { get; private set; }

    public PropertyInfo[] this[Type interfaceType]
    {
        get { return this.map[interfaceType]; }
    }
}

Sie werden für jede Schnittstelle erhalten Eigenschaften, sogar explizit umgesetzt.

Nicht verbunden mit StackOverflow
scroll top