Wie verwende ich Reflektion, um Eigenschaften zu erhalten, die explizit eine Schnittstelle implementieren? speziell

Question

Mehr, 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 ausdrücklich zu bekommen?

Danke.

Answer 1

ich Jacob Carpenter Antwort ändern musste, aber es funktioniert gut. Nobugz funktioniert auch, aber Jacobs ist kompakter.

Answer 2

Es ist übermäßig komplex. Sie müssen über die Methoden/Eigenschaften des Interface-Typs nachdenken, sehen, ob sie in Ihrem Klassentyp vorhanden sind, und sie vergleichen, um zu sehen, ob sie "gleich" sind, wenn sie existieren.

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

Answer 3

Jakobs Code fehlt einen Filter:

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

Answer 4

Die Eigenschaft Getter und Setter einer explizit implementierte Schnittstelle Eigenschaft hat eine ungewöhnliche Eigenschaft. Es ist IsFinal-Eigenschaft True, auch wenn es kein Mitglied einer versiegelten Klasse ist. 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); 
     } 
    } 
    } 

Answer 5

Hier ist eine modifizierte Lösung basierend auf der Implementierung gegeben in this 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); 

Answer 6

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

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)); 
} 

Answer 7

Aufbauend auf dem answer by MrKurt:

var targetMethods = 
    from iface in typeof(TempClass).GetInterfaces() 
    from method in typeof(TempClass).GetInterfaceMap(iface).TargetMethods 
    select method; 

var explicitProps = 
    from prop in typeof(TempClass).GetProperties(BindingFlags.Instance | 
               BindingFlags.NonPublic) 
    where targetMethods.Contains(prop.GetGetMethod(true)) || 
      targetMethods.Contains(prop.GetSetMethod(true)) 
    select prop; 

Answer 8

Dies scheint ein wenig schmerzhaft ohne ersichtlichen Grund!

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

Ich habe eine Klasse für die Herstellung von Reflexion etwas einfacher, dass ich nur auf diesen Fall hinzufügen:

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); } 
    } 
} 

You cant == auf den Namen nur tun, weil explizit implementiert Eigenschaften voll qualifizierten Namen haben.

GetProperties benötigt beide Such-Flags, um an private Eigenschaften zu gelangen.

Answer 9

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.