BindingFlags Enumeración

Definición

Espacio de nombres:

System.Reflection

Ensamblado:

System.Runtime.dll

Especifica las marcas que controlan el enlace y la manera en que la reflexión realiza la búsqueda de miembros y tipos.

Esta enumeración admite una combinación bit a bit de sus valores de miembro.

C#

[System.Flags]
public enum BindingFlags

Herencia

Object

ValueType

Enum

BindingFlags

Atributos

FlagsAttribute

Campos

Nombre	Valor	Description
CreateInstance	512	Especifica que la reflexión debe crear una instancia del tipo especificado. Llama al constructor que coincide con los argumentos especificados. El nombre de miembro proporcionado se omite. Si no se especifica el tipo de búsqueda, se aplicará (Instance | Public). No es posible llamar a un inicializador de tipo. Esta marca se pasa a un método InvokeMember para invocar un constructor.
DeclaredOnly	2	Especifica que se deben considerar solo los miembros declarados en el nivel de la jerarquía del tipo proporcionado. Los miembros heredados no se tienen en cuenta.
Default	0	Especifica que no existen marcadores de enlace definidos.
DoNotWrapExceptions	33554432
ExactBinding	65536	Especifica que los tipos de argumentos proporcionados deben coincidir exactamente con los tipos de los parámetros formales correspondientes. La reflexión inicia una excepción si el autor de la llamada proporciona un objeto no null Binder no null, ya que implica que el autor de la llamada está proporcionando implementaciones BindToXXX que captarán el método apropiado. El enlazador predeterminado ignora esta marca, mientras que los enlazadores personalizados pueden implementar la semántica de esta marca.
FlattenHierarchy	64	Especifica que se deben devolver los miembros estáticos públicos y protegidos en la jerarquía. Los miembros estáticos privados de las clases heredadas no se devuelven. Los miembros estáticos incluyen campos, métodos, eventos y propiedades. Los tipos anidados no se devuelven.
GetField	1024	Especifica que se debe devolver el valor del campo especificado. Esta marca se pasa a un método InvokeMember para obtener un valor de campo.
GetProperty	4096	Especifica que se debe devolver el valor de la propiedad especificada. Esta marca se pasa a un método InvokeMember para invocar un captador de propiedad.
IgnoreCase	1	Especifica que no se debe considerar el caso del nombre del miembro al realizar el enlace.
IgnoreReturn	16777216	Se usa en la interoperabilidad COM para especificar que se puede omitir el valor devuelto del miembro.
Instance	4	Especifica que los miembros de instancia deben incluirse en la búsqueda.
InvokeMethod	256	Especifica que se debe invocar un método. No debe ser un constructor o un inicializador de tipo. Esta marca se pasa a un método InvokeMember para invocar un método.
NonPublic	32	Especifica que los miembros no públicos deben incluirse en la búsqueda.
OptionalParamBinding	262144	Devuelve el conjunto de miembros cuyo recuento de parámetros coincide con el número de argumentos proporcionados. Esta marca de enlace se usa para los métodos con parámetros que tienen valores predeterminados y métodos con argumentos variables (varargs). Esta marca solo se debe usar con InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Los parámetros con valores predeterminados se usan solo en las llamadas en las que se omiten los argumentos finales. Deben ser los últimos argumentos.
Public	16	Especifica que los miembros públicos deben incluirse en la búsqueda.
PutDispProperty	16384	Especifica que se debe invocar el miembro PROPPUT en un objeto COM. PROPPUT especifica una función de configuración de propiedades que usa un valor. Use PutDispProperty si una propiedad tiene PROPPUT y PROPPUTREF y necesita distinguir a cuál se llama.
PutRefDispProperty	32768	Especifica que se debe invocar el miembro PROPPUTREF en un objeto COM. PROPPUTREF especifica una función de configuración de propiedades que usa una referencia en lugar de un valor. Use PutRefDispProperty si una propiedad tiene PROPPUT y PROPPUTREF y necesita distinguir a cuál se llama.
SetField	2048	Especifica que se debe establecer el valor del campo especificado. Esta marca se pasa a un método InvokeMember para establecer un valor de campo.
SetProperty	8192	Especifica que se debe establecer el valor de la propiedad especificada. Para las propiedades COM, especificar esta marca de enlace equivale a especificar PutDispProperty y PutRefDispProperty. Esta marca se pasa a un método InvokeMember para invocar un configurador de propiedad.
Static	8	Especifica que los miembros estáticos deben incluirse en la búsqueda.
SuppressChangeType	131072	Sin implementar.

Ejemplos

En el ejemplo siguiente se muestran muchas de las marcas de enlace.

C#

using System;
using System.Reflection;
using System.IO;

namespace BindingFlagsSnippet
{
    class Example
    {
        static void Main()
        {
            // BindingFlags.InvokeMethod
            // Call a static method.
            Type t = typeof (TestClass);

            Console.WriteLine();
            Console.WriteLine("Invoking a static method.");
            Console.WriteLine("-------------------------");
            t.InvokeMember ("SayHello", BindingFlags.InvokeMethod | BindingFlags.Public |
                BindingFlags.Static, null, null, new object [] {});

            // BindingFlags.InvokeMethod
            // Call an instance method.
            TestClass c = new TestClass ();
            Console.WriteLine();
            Console.WriteLine("Invoking an instance method.");
            Console.WriteLine("----------------------------");
            c.GetType().InvokeMember ("AddUp", BindingFlags.InvokeMethod, null, c, new object [] {});
            c.GetType().InvokeMember ("AddUp", BindingFlags.InvokeMethod, null, c, new object [] {});

            // BindingFlags.InvokeMethod
            // Call a method with parameters.
            object [] args = new object [] {100.09, 184.45};
            object result;
            Console.WriteLine();
            Console.WriteLine("Invoking a method with parameters.");
            Console.WriteLine("---------------------------------");
            result = t.InvokeMember ("ComputeSum", BindingFlags.InvokeMethod, null, null, args);
            Console.WriteLine ("{0} + {1} = {2}", args[0], args[1], result);

            // BindingFlags.GetField, SetField
            Console.WriteLine();
            Console.WriteLine("Invoking a field (getting and setting.)");
            Console.WriteLine("--------------------------------------");
            // Get a field value.
            result = t.InvokeMember ("Name", BindingFlags.GetField, null, c, new object [] {});
            Console.WriteLine ("Name == {0}", result);
            // Set a field.
            t.InvokeMember ("Name", BindingFlags.SetField, null, c, new object [] {"NewName"});
            result = t.InvokeMember ("Name", BindingFlags.GetField, null, c, new object [] {});
            Console.WriteLine ("Name == {0}", result);

            Console.WriteLine();
            Console.WriteLine("Invoking an indexed property (getting and setting.)");
            Console.WriteLine("--------------------------------------------------");
            // BindingFlags.GetProperty
            // Get an indexed property value.
            int  index = 3;
            result = t.InvokeMember ("Item", BindingFlags.GetProperty, null, c, new object [] {index});
            Console.WriteLine ("Item[{0}] == {1}", index, result);
            // BindingFlags.SetProperty
            // Set an indexed property value.
            index = 3;
            t.InvokeMember ("Item", BindingFlags.SetProperty, null, c, new object [] {index, "NewValue"});
            result = t.InvokeMember ("Item", BindingFlags.GetProperty , null, c, new object [] {index});
            Console.WriteLine ("Item[{0}] == {1}", index, result);

            Console.WriteLine();
            Console.WriteLine("Getting a field or property.");
            Console.WriteLine("----------------------------");
            // BindingFlags.GetField
            // Get a field or property.
            result = t.InvokeMember ("Name", BindingFlags.GetField | BindingFlags.GetProperty, null, c,
                new object [] {});
            Console.WriteLine ("Name == {0}", result);
            // BindingFlags.GetProperty
            result = t.InvokeMember ("Value", BindingFlags.GetField | BindingFlags.GetProperty, null, c,
                new object [] {});
            Console.WriteLine ("Value == {0}", result);

            Console.WriteLine();
            Console.WriteLine("Invoking a method with named parameters.");
            Console.WriteLine("---------------------------------------");
            // BindingFlags.InvokeMethod
            // Call a method using named parameters.
            object[] argValues = new object [] {"Mouse", "Micky"};
            String [] argNames = new String [] {"lastName", "firstName"};
            t.InvokeMember ("PrintName", BindingFlags.InvokeMethod, null, null, argValues, null, null,
                argNames);

            Console.WriteLine();
            Console.WriteLine("Invoking a default member of a type.");
            Console.WriteLine("------------------------------------");
            // BindingFlags.Default
            // Call the default member of a type.
            Type t3 = typeof (TestClass2);
            t3.InvokeMember ("", BindingFlags.InvokeMethod | BindingFlags.Default, null, new TestClass2(),
                new object [] {});

            // BindingFlags.Static, NonPublic, and Public
            // Invoking a member with ref parameters.
            Console.WriteLine();
            Console.WriteLine("Invoking a method with ref parameters.");
            Console.WriteLine("--------------------------------------");
            MethodInfo m = t.GetMethod("Swap");
            args = new object[2];
            args[0] = 1;
            args[1] = 2;
            m.Invoke(new TestClass(),args);
            Console.WriteLine ("{0}, {1}", args[0], args[1]);

            // BindingFlags.CreateInstance
            // Creating an instance with a parameterless constructor.
            Console.WriteLine();
            Console.WriteLine("Creating an instance with a parameterless constructor.");
            Console.WriteLine("------------------------------------------------------");
            object cobj = t.InvokeMember ("TestClass", BindingFlags.Public |
                BindingFlags.Instance | BindingFlags.CreateInstance,
                null, null, new object [] {});
            Console.WriteLine("Instance of {0} created.", cobj.GetType().Name);

            // Creating an instance with a constructor that has parameters.
            Console.WriteLine();
            Console.WriteLine("Creating an instance with a constructor that has parameters.");
            Console.WriteLine("------------------------------------------------------------");
            cobj = t.InvokeMember ("TestClass", BindingFlags.Public |
                BindingFlags.Instance | BindingFlags.CreateInstance,
                null, null, new object [] { "Hello, World!" });
            Console.WriteLine("Instance of {0} created with initial value '{1}'.", cobj.GetType().Name,
                cobj.GetType().InvokeMember("Name", BindingFlags.GetField, null, cobj, null));

            // BindingFlags.DeclaredOnly
            Console.WriteLine();
            Console.WriteLine("DeclaredOnly instance members.");
            Console.WriteLine("------------------------------");
            System.Reflection.MemberInfo[] memInfo =
                t.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance |
                BindingFlags.Public);
            for(int i=0;i<memInfo.Length;i++)
            {
                Console.WriteLine(memInfo[i].Name);
            }

            // BindingFlags.IgnoreCase
            Console.WriteLine();
            Console.WriteLine("Using IgnoreCase and invoking the PrintName method.");
            Console.WriteLine("---------------------------------------------------");
            t.InvokeMember("printname", BindingFlags.IgnoreCase | BindingFlags.Static |
                BindingFlags.Public | BindingFlags.InvokeMethod, null, null, new object[]
                {"Brad","Smith"});

            // BindingFlags.FlattenHierarchy
            Console.WriteLine();
            Console.WriteLine("Using FlattenHierarchy to get inherited static protected and public members." );
            Console.WriteLine("----------------------------------------------------------------------------");
            FieldInfo[] finfos = typeof(MostDerived).GetFields(BindingFlags.NonPublic | BindingFlags.Public |
                  BindingFlags.Static | BindingFlags.FlattenHierarchy);
            foreach (FieldInfo finfo in finfos)
            {
                Console.WriteLine("{0} defined in {1}.", finfo.Name, finfo.DeclaringType.Name);
            }

            Console.WriteLine();
            Console.WriteLine("Without FlattenHierarchy." );
            Console.WriteLine("-------------------------");
            finfos = typeof(MostDerived).GetFields(BindingFlags.NonPublic | BindingFlags.Public |
                  BindingFlags.Static);
            foreach (FieldInfo finfo in finfos)
            {
                Console.WriteLine("{0} defined in {1}.", finfo.Name, finfo.DeclaringType.Name);
            }
        }
    }

    public class TestClass
    {
        public String Name;
        private Object [] values = new Object [] {0, 1,2,3,4,5,6,7,8,9};

        public Object this [int index]
        {
            get
            {
                return values[index];
            }
            set
            {
                values[index] = value;
            }
        }

        public Object Value
        {
            get
            {
                return "the value";
            }
        }

        public TestClass () : this("initialName") {}
        public TestClass (string initName)
        {
            Name = initName;
        }

        int methodCalled = 0;

        public static void SayHello ()
        {
            Console.WriteLine ("Hello");
        }

        public void AddUp ()
        {
            methodCalled++;
            Console.WriteLine ("AddUp Called {0} times", methodCalled);
        }

        public static double ComputeSum (double d1, double d2)
        {
            return d1 + d2;
        }

        public static void PrintName (String firstName, String lastName)
        {
            Console.WriteLine ("{0},{1}", lastName,firstName);
        }

        public void PrintTime ()
        {
            Console.WriteLine (DateTime.Now);
        }

        public void Swap(ref int a, ref int b)
        {
            int x = a;
            a = b;
            b = x;
        }
    }

    [DefaultMemberAttribute ("PrintTime")]
    public class TestClass2
    {
        public void PrintTime ()
        {
            Console.WriteLine (DateTime.Now);
        }
    }

    public class Base
    {
        static int BaseOnlyPrivate = 0;
        protected static int BaseOnly = 0;
    }
    public class Derived : Base
    {
        public static int DerivedOnly = 0;
    }
    public class MostDerived : Derived {}
}

/* This example produces output similar to the following:

Invoking a static method.
-------------------------
Hello

Invoking an instance method.
----------------------------
AddUp Called 1 times
AddUp Called 2 times

Invoking a method with parameters.
---------------------------------
100.09 + 184.45 = 284.54

Invoking a field (getting and setting.)
--------------------------------------
Name == initialName
Name == NewName

Invoking an indexed property (getting and setting.)
--------------------------------------------------
Item[3] == 3
Item[3] == NewValue

Getting a field or property.
----------------------------
Name == NewName
Value == the value

Invoking a method with named parameters.
---------------------------------------
Mouse,Micky

Invoking a default member of a type.
------------------------------------
12/23/2009 4:29:21 PM

Invoking a method with ref parameters.
--------------------------------------
2, 1

Creating an instance with a parameterless constructor.
------------------------------------------------------
Instance of TestClass created.

Creating an instance with a constructor that has parameters.
------------------------------------------------------------
Instance of TestClass created with initial value 'Hello, World!'.

DeclaredOnly instance members.
------------------------------
get_Item
set_Item
get_Value
AddUp
PrintTime
Swap
.ctor
.ctor
Item
Value
Name

Using IgnoreCase and invoking the PrintName method.
---------------------------------------------------
Smith,Brad

Using FlattenHierarchy to get inherited static protected and public members.
----------------------------------------------------------------------------
DerivedOnly defined in Derived.
BaseOnly defined in Base.

Without FlattenHierarchy.
-------------------------

 */

Comentarios

Estos BindingFlags enlaces de control para una gran cantidad de clases en los Systemespacios de nombres , System.Reflectiony System.Runtime que invocan, crean, obtienen, establecen y buscan miembros y tipos.

BindingFlags se usan en los métodos siguientes Type y en otros lugares, como MethodBase.Invoke:

• MethodBase.Invoke

• GetMembers

• GetEvents

• InvokeMember

• Activator.CreateInstance

• GetConstructor

• GetConstructors

• GetMethod

• GetMethods

• GetField

• GetFields

• GetEvent

• GetProperty

• GetProperties

• GetMember

• FindMembers

InvokeMember y GetMethod son especialmente importantes.

Las marcas de enlace se pueden clasificar por cómo identifican un miembro de tipo, como se muestra en la tabla siguiente.

Identificado por accesibilidad	Identificado por el argumento binding	Identificado por operación
DeclareOnly FlattenHierarchy IgnoreCase IgnoreReturn Instancia Privada Público Estático	ExactBinding OptionalParamBinding	CreateInstance GetField SetField GetProperty SetProperty InvokeMethod PutDispProperty PutRefDispProperty

Nota

Debe especificar Instance o Static junto con Public o NonPublic ningún miembro se devolverá.

En la tabla siguiente se enumeran las coerciones realizadas por el valor predeterminado Binder.ChangeType. Esta tabla se aplica especialmente a la marca de BindingFlags.ExactBinding enlace. El principio general es que ChangeType solo debe realizar coerciones de ampliación, que nunca pierden datos. Un ejemplo de una coerción de ampliación es convertir un valor que es un entero de 32 bits con signo en un valor que es un entero de 64 bits con signo. Esto se distingue de una coerción de restricción, que puede perder datos. Un ejemplo de una coerción de restricción consiste en convertir un entero de 64 bits con signo en un entero de 32 bits con signo.

Tipo de origen	Tipo de destino
Cualquier tipo	Su tipo base.
Cualquier tipo	La interfaz que implementa.
Char	UInt16, UInt32, Int32, UInt64, Int64, Single, Double
Byte	Char, UInt16, Int16, UInt32, Int32, UInt64, Int64, Single, Double
SByte	Int16, Int32, Int64, Single, Double
UInt16	UInt32, Int32, UInt64, Int64, Single, Double
Int16	Int32, Int64, Single, Double
UInt32	UInt64, Int64, Single, Double
Int32	Int64, Single, Double
UInt64	Single, Double
Int64	Single, Double
Single	Double
No referencia	Por referencia.

Cuando se usa la BindingFlags.ExactBinding marca de enlace, la reflexión modela las reglas de accesibilidad del sistema de tipos comunes. Por ejemplo, si el autor de la llamada está en el mismo ensamblado, el autor de la llamada no necesita permisos especiales para los miembros internos. De lo contrario, el autor de la llamada necesita ReflectionPermission. Esto es coherente con la búsqueda de miembros protegidos, privados, etc.

Se aplica a