Come ottenere una proprietà statica con Reflection

Quindi questo sembra piuttosto semplice ma non riesco a farlo funzionare. Ho un oggetto e utilizzo la riflessione per accedere alle sue proprietà pubbliche. Una di queste proprietà è statica e non ho fortuna ad arrivarci.

Public Function GetProp(ByRef obj As Object, ByVal propName as String) as PropertyInfo
    Return obj.GetType.GetProperty(propName)

End Function

Il codice sopra funziona bene per le proprietà dell'istanza pubblica, che fino ad ora è tutto ciò di cui avevo bisogno. Presumibilmente posso usare BindingFlags per richiedere altri tipi di proprietà (private, statiche), ma non riesco a trovare la giusta combinazione.

Public Function GetProp(ByRef obj As Object, ByVal propName as String) as PropertyInfo
    Return obj.GetType.GetProperty(propName, Reflection.BindingFlags.Static Or Reflection.BindingFlags.Instance Or Reflection.BindingFlags.Public)

End Function

Tuttavia, la richiesta di qualsiasi membro statico non restituisce nulla. Il riflettore .NET può vedere le proprietà statiche bene, quindi chiaramente mi manca qualcosa qui.

O guarda questo ...

Type type = typeof(MyClass); // MyClass is static class with static properties
foreach (var p in type.GetProperties())
{
   var v = p.GetValue(null, null); // static classes cannot be instanced, so use null...
}

Questo è C #, ma dovrebbe darti l'idea:

public static void Main() {
    typeof(Program).GetProperty("GetMe", BindingFlags.NonPublic | BindingFlags.Static);
}

private static int GetMe {
    get { return 0; }
}

(è necessario OR Non pubblico e solo statico)

Un po 'di chiarezza ...

// Get a PropertyInfo of specific property type(T).GetProperty(....)
PropertyInfo propertyInfo;
propertyInfo = typeof(TypeWithTheStaticProperty)
    .GetProperty("NameOfStaticProperty", BindingFlags.Public | BindingFlags.Static); 

// Use the PropertyInfo to retrieve the value from the type by not passing in an instance
object value = propertyInfo.GetValue(null, null);

// Cast the value to the desired type
ExpectedType typedValue = (ExpectedType) value;

Ok, quindi la chiave per me era usare .FlattenHierarchy BindingFlag. Non so davvero perché l'ho aggiunto per intuizione e ha iniziato a funzionare. Quindi la soluzione finale che mi permette di ottenere istanze pubbliche o proprietà statiche è:

obj.GetType.GetProperty(propName, Reflection.BindingFlags.Public _
  Or Reflection.BindingFlags.Static Or Reflection.BindingFlags.Instance Or _
  Reflection.BindingFlags.FlattenHierarchy)

myType.GetProperties(BindingFlags.Public | BindingFlags.Static |  BindingFlags.FlattenHierarchy);

Ciò restituirà tutte le proprietà statiche nella classe base statica o in un tipo particolare e probabilmente anche nel figlio.

Volevo solo chiarire questo per me stesso, mentre utilizzavo la nuova API di riflessione basata su TypeInfo- doveBindingFlags non è disponibile in modo affidabile (a seconda del framework di destinazione).

Nella riflessione 'nuova', per ottenere le proprietà statiche per un tipo (escluse le classi base) devi fare qualcosa come:

IEnumerable<PropertyInfo> props = 
  type.GetTypeInfo().DeclaredProperties.Where(p => 
    (p.GetMethod != null && p.GetMethod.IsStatic) ||
    (p.SetMethod != null && p.SetMethod.IsStatic));

Fornisce proprietà di sola lettura o di sola scrittura (nonostante la sola scrittura sia un'idea terribile).

Anche il DeclaredPropertiesmembro non distingue tra proprietà con funzioni di accesso pubbliche / private, quindi per filtrare la visibilità, devi farlo in base alla funzione di accesso che devi utilizzare. Ad esempio, supponendo che la chiamata di cui sopra sia tornata, potresti fare:

var publicStaticReadable = props.Where(p => p.GetMethod != null && p.GetMethod.IsPublic);

Sono disponibili alcuni metodi di scelta rapida, ma alla fine scriveremo tutti molti più metodi di estensione sui TypeInfometodi / proprietà di query in futuro. Inoltre, la nuova API ci costringe a pensare esattamente a ciò che pensiamo come una proprietà "privata" o "pubblica" da ora in poi, perché dobbiamo filtrare noi stessi in base ai singoli accessor.

Quanto segue sembra funzionare per me.

using System;
using System.Reflection;

public class ReflectStatic
{
    private static int SomeNumber {get; set;}
    public static object SomeReference {get; set;}
    static ReflectStatic()
    {
        SomeReference = new object();
        Console.WriteLine(SomeReference.GetHashCode());
    }
}

public class Program
{
    public static void Main()
    {
        var rs = new ReflectStatic();
        var pi = rs.GetType().GetProperty("SomeReference",  BindingFlags.Static | BindingFlags.Public);
        if(pi == null) { Console.WriteLine("Null!"); Environment.Exit(0);}
        Console.WriteLine(pi.GetValue(rs, null).GetHashCode());


    }
}

Prova questo C # Reflection collegamento .

Nota Penso che BindingFlags.Instance e BindingFlags.Static siano esclusivi.