Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C#

BindingFlags: filtrar métodos mediante reflexión

Combina marcas de búsqueda para seleccionar métodos por su visibilidad, por su carácter estático o de instancia y por el tipo que los declara.

Versión: C# 12 and .NET 8; later runtimes may add compatible features

Sintaxis

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 es una enumeración de .NET marcada con el atributo [Flags]. Importa System.Reflection con using para escribir el nombre corto BindingFlags. Combina las marcas con el operador O bit a bit (|), no con ||, y pasa el resultado a Type.GetMethods(BindingFlags).

La visibilidad y la clase de método son filtros independientes. Public incluye métodos públicos y NonPublic, métodos no públicos. Instance selecciona métodos de instancia y Static, métodos estáticos. Indica al menos una marca de cada par. También puedes indicar ambas: Public | Instance | Static admite métodos públicos de los dos tipos.

DeclaredOnly limita la búsqueda a los métodos declarados directamente en el tipo inspeccionado. Sin esta marca, pueden aparecer métodos de instancia heredados que cumplan los criterios. En una búsqueda de métodos estáticos, FlattenHierarchy permite incluir los métodos estáticos públicos y protegidos de las clases base, según el filtro de visibilidad, pero no sus métodos estáticos privados.

La sobrecarga con marcas devuelve un MethodInfo[]: describe los métodos sin invocarlos. Devuelve un array vacío si falta alguna de las dos categorías de marcas obligatorias o si nada coincide. Por eso, GetMethods(BindingFlags.Default) no equivale a GetMethods() sin parámetros, que busca métodos públicos.

Ejemplos

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() { }
}

Resultado

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

En este ejemplo para C# 12 y .NET 8, `Public` excluye `Debug`. Sin `DeclaredOnly`, la búsqueda de métodos de instancia también encuentra `Reset` y los métodos públicos de instancia de `object`. Con `FlattenHierarchy`, la búsqueda de métodos estáticos encuentra `Help`. Esa búsqueda también encuentra los métodos estáticos `Equals` y `ReferenceEquals` declarados en `object`, pero el código los excluye antes de mostrar los resultados. El código ordena los nombres explícitamente en lugar de depender del orden de los metadatos.

Lecciones relacionadas

  • C# · Lección 23 · Avanzado · Versión: 3

Fuentes