Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C#

BindingFlags: filtrare i metodi tramite reflection

Combina i flag di ricerca per selezionare i metodi in base alla visibilità, al fatto che siano statici o di istanza e al tipo che li dichiara.

Versione: C# 12 and .NET 8; later runtimes may add compatible features

Sintassi

using System.Reflection;

BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
MethodInfo[] methods = typeof(T).GetMethods(flags); // T is the type to inspect.
// Use BindingFlags.Static instead of Instance for static methods,
// or combine Instance | Static to include both.

System.Reflection.BindingFlags è un'enumerazione di .NET contrassegnata con l'attributo [Flags]. Importa System.Reflection con using per usare il nome breve BindingFlags. Combina i flag con l'OR bit per bit (|), non con ||, e passa il risultato a Type.GetMethods(BindingFlags).

La visibilità e il genere di metodo sono filtri indipendenti. Public include i metodi pubblici e NonPublic quelli non pubblici. Instance seleziona i metodi di istanza e Static quelli statici. Specifica almeno un flag di ciascuna coppia. Puoi anche specificarli entrambi: Public | Instance | Static ammette i metodi pubblici di entrambi i generi.

DeclaredOnly limita la ricerca ai metodi dichiarati direttamente nel tipo esaminato. Senza questo flag possono comparire i metodi di istanza ereditati che soddisfano i criteri. Nella ricerca di metodi statici, FlattenHierarchy consente di includere i metodi statici pubblici e protetti delle classi base, a seconda del filtro di visibilità, ma non i loro metodi statici privati.

L'overload con i flag restituisce un MethodInfo[]: descrive i metodi senza invocarli. Restituisce un array vuoto se manca una delle due categorie di flag richieste o se nessun metodo corrisponde ai criteri. Perciò GetMethods(BindingFlags.Default) non equivale a GetMethods() senza parametri, che cerca i metodi pubblici.

Esempi

using System;
using System.Linq;
using System.Reflection;

Type type = typeof(Player);
const BindingFlags publicInstance = BindingFlags.Public | BindingFlags.Instance;
const BindingFlags publicStatic = BindingFlags.Public | BindingFlags.Static;

Print("Instance here", type, publicInstance | BindingFlags.DeclaredOnly);
Print("Static here", type, publicStatic | BindingFlags.DeclaredOnly);
Print("Instance including inherited", type, publicInstance);
Print("Static including inherited", type, publicStatic | BindingFlags.FlattenHierarchy);

static void Print(string label, Type type, BindingFlags flags)
{
    var names = type.GetMethods(flags)
        // Keep object instance methods, but omit static methods declared on object.
        .Where(method => !method.IsStatic || method.DeclaringType != typeof(object))
        .Select(method => method.Name)
        .OrderBy(name => name, StringComparer.Ordinal);

    Console.WriteLine($"{label}: {string.Join(", ", names)}");
}

class BasePlayer
{
    public void Reset() { }
    public static void Help() { }
}

class Player : BasePlayer
{
    public void Play() { }
    public static void Create() { }
    private void Debug() { }
}

Risultato

Instance here: Play
Static here: Create
Instance including inherited: Equals, GetHashCode, GetType, Play, Reset, ToString
Static including inherited: Create, Help

Nell'esempio per C# 12 e .NET 8, `Public` esclude `Debug`. Senza `DeclaredOnly`, la ricerca dei metodi di istanza trova anche `Reset` e i metodi di istanza pubblici di `object`. Con `FlattenHierarchy`, la ricerca dei metodi statici trova `Help`. La ricerca trova anche i metodi statici `Equals` e `ReferenceEquals` dichiarati in `object`, ma il codice li esclude prima di stampare i risultati. Il codice ordina esplicitamente i nomi senza dipendere dall'ordine dei metadati.

Lezioni correlate

  • C# · Lezione 23 · Avanzato · Versione: 3

Fonti