Type.GetConstructor Método

Definición

Obtiene un constructor específico del objeto Type actual.Gets a specific constructor of the current Type.

Sobrecargas

GetConstructor(Type[])

Busca un constructor de instancia público cuyos parámetros coincidan con los tipos de la matriz especificada.Searches for a public instance constructor whose parameters match the types in the specified array.

GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Busca un constructor cuyos parámetros coincidan con los tipos y modificadores de argumento especificados, mediante las restricciones de enlace también especificadas.Searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints.

GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Busca un constructor cuyos parámetros coincidan con los modificadores y tipos de argumento especificados, mediante las restricciones de enlace indicadas y la convención de llamadas también especificada.Searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

GetConstructor(Type[])

Busca un constructor de instancia público cuyos parámetros coincidan con los tipos de la matriz especificada.Searches for a public instance constructor whose parameters match the types in the specified array.

public:
 virtual System::Reflection::ConstructorInfo ^ GetConstructor(cli::array <Type ^> ^ types);
[System.Runtime.InteropServices.ComVisible(true)]
public System.Reflection.ConstructorInfo GetConstructor (Type[] types);
abstract member GetConstructor : Type[] -> System.Reflection.ConstructorInfo
override this.GetConstructor : Type[] -> System.Reflection.ConstructorInfo
Public Function GetConstructor (types As Type()) As ConstructorInfo

Parámetros

types
Type[]

Matriz de objetos Type que representa el número, el orden y el tipo de los parámetros del constructor deseado.An array of Type objects representing the number, order, and type of the parameters for the desired constructor.

O bien-or- Matriz vacía de objetos Type, para obtener un constructor que no requiera parámetros.An empty array of Type objects, to get a constructor that takes no parameters. El campo static EmptyTypes proporciona dicha matriz vacía.Such an empty array is provided by the static field EmptyTypes.

Devoluciones

Objeto que representa el constructor de instancia público cuyos parámetros coinciden con los tipos de la matriz de tipos de parámetro, si se encuentra; de lo contrario, es null.An object representing the public instance constructor whose parameters match the types in the parameter type array, if found; otherwise, null.

Implementaciones

Atributos

Excepciones

types es null.types is null.

O bien-or- Uno de los elementos de types es null.One of the elements in types is null.

types es multidimensional.types is multidimensional.

Ejemplos

En el ejemplo siguiente se obtiene el tipo MyClassde, se ConstructorInfo obtiene el objeto y se muestra la firma del constructor.The following example obtains the type of MyClass, gets the ConstructorInfo object, and displays the constructor signature.

using namespace System;
using namespace System::Reflection;
using namespace System::Security;
public ref class MyClass1
{
public:
   MyClass1(){}

   MyClass1( int i ){}

};

int main()
{
   try
   {
      Type^ myType = MyClass1::typeid;
      array<Type^>^types = gcnew array<Type^>(1);
      types[ 0 ] = int::typeid;
      
      // Get the constructor that takes an integer as a parameter.
      ConstructorInfo^ constructorInfoObj = myType->GetConstructor( types );
      if ( constructorInfoObj != nullptr )
      {
         Console::WriteLine( "The constructor of MyClass1 that takes an integer as a parameter is: " );
         Console::WriteLine( constructorInfoObj );
      }
      else
      {
         Console::WriteLine( "The constructor of MyClass1 that takes an integer as a parameter is not available." );
      }
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception caught." );
      Console::WriteLine( "Source: {0}", e->Source );
      Console::WriteLine( "Message: {0}", e->Message );
   }
}

using System;
using System.Reflection;
using System.Security;

public class MyClass1
{
    public MyClass1(){}
    public MyClass1(int i){}

    public static void Main()
    {
        try
        {
            Type myType = typeof(MyClass1);
            Type[] types = new Type[1];
            types[0] = typeof(int);
            // Get the constructor that takes an integer as a parameter.
            ConstructorInfo constructorInfoObj = myType.GetConstructor(types);
            if (constructorInfoObj != null)
            {
                Console.WriteLine("The constructor of MyClass1 that takes an " + 
                    "integer as a parameter is: "); 
                Console.WriteLine(constructorInfoObj.ToString());
            }
            else
            {
                Console.WriteLine("The constructor of MyClass1 that takes an integer " +
                    "as a parameter is not available."); 
            }
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception caught.");
            Console.WriteLine("Source: " + e.Source);
            Console.WriteLine("Message: " + e.Message);
        }
    }
}
Imports System.Reflection
Imports System.Security

Public Class MyClass1

    Public Sub New()
    End Sub

    Public Sub New(ByVal i As Integer)
    End Sub

    Public Shared Sub Main()
        Try
            Dim myType As Type = GetType(MyClass1)
            Dim types(0) As Type
            types(0) = GetType(Int32)
            ' Get the constructor that takes an integer as a parameter.
            Dim constructorInfoObj As ConstructorInfo = myType.GetConstructor(types)
            If Not (constructorInfoObj Is Nothing) Then
                Console.WriteLine("The constructor of MyClass that takes an integer as a parameter is: ")
                Console.WriteLine(constructorInfoObj.ToString())
            Else
                Console.WriteLine("The constructor of MyClass that takes no " + "parameters is not available.")
            End If

        Catch e As Exception
            Console.WriteLine("Exception caught.")
            Console.WriteLine(("Source: " + e.Source))
            Console.WriteLine(("Message: " + e.Message))
        End Try
    End Sub
End Class

Comentarios

Esta sobrecarga del método busca constructores de instancia públicos y no se puede usar para obtener un inicializador de clase (constructor estático).This method overload looks for public instance constructors and cannot be used to obtain a class initializer (static constructor). Para obtener un inicializador de clase, use una sobrecarga que BindingFlagstome y especifique BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.Static Or BindingFlags.NonPublic en Visual Basic).To get a class initializer, use an overload that takes BindingFlags, and specify BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.StaticOrBindingFlags.NonPublic in Visual Basic). También puede obtener el inicializador de clase mediante la TypeInitializer propiedad.You can also get the class initializer using the TypeInitializer property.

Si el constructor solicitado no es público, este método devuelve null.If the requested constructor is non-public, this method returns null.

Nota

No se pueden omitir los parámetros al buscar constructores y métodos.You cannot omit parameters when looking up constructors and methods. Solo se pueden omitir los parámetros al invocar a.You can only omit parameters when invoking.

Si el actual Type representa un tipo genérico construido, este método ConstructorInfo devuelve con los parámetros de tipo reemplazados por los argumentos de tipo adecuados.If the current Type represents a constructed generic type, this method returns the ConstructorInfo with the type parameters replaced by the appropriate type arguments. Si el actual Type representa un parámetro de tipo en la definición de un tipo genérico o de un método genérico, este nullmétodo siempre devuelve.If the current Type represents a type parameter in the definition of a generic type or generic method, this method always returns null.

Consulte también:

GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Busca un constructor cuyos parámetros coincidan con los tipos y modificadores de argumento especificados, mediante las restricciones de enlace también especificadas.Searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints.

public:
 virtual System::Reflection::ConstructorInfo ^ GetConstructor(System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
[System.Runtime.InteropServices.ComVisible(true)]
public System.Reflection.ConstructorInfo GetConstructor (System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, Type[] types, System.Reflection.ParameterModifier[] modifiers);
abstract member GetConstructor : System.Reflection.BindingFlags * System.Reflection.Binder * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.ConstructorInfo
override this.GetConstructor : System.Reflection.BindingFlags * System.Reflection.Binder * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.ConstructorInfo

Parámetros

bindingAttr
BindingFlags

Combinación bit a bit de los valores de enumeración que especifican cómo se realiza la búsqueda.A bitwise combination of the enumeration values that specify how the search is conducted.

o bien-or- Default para devolver null.Default to return null.

binder
Binder

Objeto que define un conjunto de propiedades y permite realizar operaciones de enlace, que pueden incluir la selección de un método sobrecargado, la coerción de tipos de argumentos y la invocación de un miembro mediante reflexión.An object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

O bien-or- Referencia nula (Nothing en Visual Basic) para usar la propiedad DefaultBinder.A null reference (Nothing in Visual Basic), to use the DefaultBinder.

types
Type[]

Matriz de objetos Type que representa el número, el orden y el tipo de parámetros que el constructor debe obtener.An array of Type objects representing the number, order, and type of the parameters for the constructor to get.

o bien-or- Matriz vacía del tipo Type (es decir, Type[] types = new Type[0]) para obtener un constructor que no requiera parámetros.An empty array of the type Type (that is, Type[] types = new Type[0]) to get a constructor that takes no parameters.

o bien-or- EmptyTypes.EmptyTypes.

modifiers
ParameterModifier[]

Matriz de objetos ParameterModifier que representan los atributos asociados al elemento correspondiente de la matriz de tipo de parámetro.An array of ParameterModifier objects representing the attributes associated with the corresponding element in the parameter type array. El enlazador predeterminado no procesa este parámetro.The default binder does not process this parameter.

Devoluciones

Objeto ConstructorInfo que representa el constructor que cumple los requisitos especificados, si se encuentra; en caso contrario, es null.A ConstructorInfo object representing the constructor that matches the specified requirements, if found; otherwise, null.

Implementaciones

Atributos

Excepciones

types es null.types is null.

O bien-or- Uno de los elementos de types es null.One of the elements in types is null.

types es multidimensional.types is multidimensional.

O bien-or- modifiers es multidimensional.modifiers is multidimensional.

O bien-or- types y modifiers no tienen la misma longitud.types and modifiers do not have the same length.

Ejemplos

El siguiente programa obtiene el tipo de MyClass1 clase, obtiene el ConstructorInfo objeto que coincide con las marcas de enlace especificadas y muestra la firma del constructor.The following program obtains the type of MyClass1 class, gets the ConstructorInfo object matching the specified binding flags, and displays the signature of the constructor.

using namespace System;
using namespace System::Reflection;
using namespace System::Security;
public ref class MyClass1
{
public:
   MyClass1( int i ){}

};

int main()
{
   try
   {
      Type^ myType = MyClass1::typeid;
      array<Type^>^types = gcnew array<Type^>(1);
      types[ 0 ] = int::typeid;
      
      // Get the constructor that is public and takes an integer parameter.
      ConstructorInfo^ constructorInfoObj = myType->GetConstructor( static_cast<BindingFlags>(BindingFlags::Instance | BindingFlags::Public), nullptr, types, nullptr );
      if ( constructorInfoObj != nullptr )
      {
         Console::WriteLine( "The constructor of MyClass1 that is public and takes an integer as a parameter is:" );
         Console::WriteLine( constructorInfoObj );
      }
      else
      {
         Console::WriteLine( "The constructor of the MyClass1 that is public and takes an integer as a parameter is not available." );
      }
   }
   catch ( ArgumentNullException^ e ) 
   {
      Console::WriteLine( "ArgumentNullException: {0}", e->Message );
   }
   catch ( ArgumentException^ e ) 
   {
      Console::WriteLine( "ArgumentException: {0}", e->Message );
   }
   catch ( SecurityException^ e ) 
   {
      Console::WriteLine( "SecurityException: {0}", e->Message );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: {0}", e->Message );
   }
}
using System;
using System.Reflection;
using System.Security;


public class MyClass1
{
    public MyClass1(int i){}
    public static void Main()
    {
        try
        {
            Type myType = typeof(MyClass1);
            Type[] types = new Type[1];
            types[0] = typeof(int);
            // Get the constructor that is public and takes an integer parameter.
            ConstructorInfo constructorInfoObj = myType.GetConstructor(
                BindingFlags.Instance | BindingFlags.Public, null, types, null);
            if (constructorInfoObj != null )
            {
                Console.WriteLine("The constructor of MyClass1 that is public " +
                    "and takes an integer as a parameter is:");
                Console.WriteLine(constructorInfoObj.ToString());
            }
            else
            {
                Console.WriteLine("The constructor of the MyClass1 that is public " +
                    "and takes an integer as a parameter is not available.");
            }
        }
        catch(ArgumentNullException e)
        {
            Console.WriteLine("ArgumentNullException: " + e.Message);
        }
        catch(ArgumentException e)
        {
            Console.WriteLine("ArgumentException: " + e.Message);
        }
        catch(SecurityException e)
        {
            Console.WriteLine("SecurityException: " + e.Message);
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception: " + e.Message);
        }
    }
}
Imports System.Reflection
Imports System.Security


Public Class MyClass1
    Public Sub New(ByVal i As Integer)
    End Sub

    Public Shared Sub Main()
        Try
            Dim myType As Type = GetType(MyClass1)
            Dim types(0) As Type
            types(0) = GetType(Integer)
            ' Get the constructor that is public and takes an integer parameter.
            Dim constructorInfoObj As ConstructorInfo = _
                     myType.GetConstructor(BindingFlags.Instance Or _
                     BindingFlags.Public, Nothing, types, Nothing)
            If Not (constructorInfoObj Is Nothing) Then
                Console.WriteLine("The constructor of MyClass1 that is " + _
                               "public and takes an integer as a parameter is ")
                Console.WriteLine(constructorInfoObj.ToString())
            Else
                Console.WriteLine("The constructor of MyClass1 that is " + _
                  "public and takes an integer as a parameter is not available.")
            End If
        Catch e As ArgumentNullException
            Console.WriteLine("ArgumentNullException: " + e.Message)
        Catch e As ArgumentException
            Console.WriteLine("ArgumentException: " + e.Message)
        Catch e As SecurityException
            Console.WriteLine("SecurityException: " + e.Message)
        Catch e As Exception
            Console.WriteLine("Exception: " + e.Message)
        End Try
    End Sub
End Class

Comentarios

Si no existe una coincidencia exacta, binder intentará convertir los tipos de parámetro especificados en la types matriz para seleccionar una coincidencia.If an exact match does not exist, the binder will attempt to coerce the parameter types specified in the types array in order to select a match. Si no puede seleccionar una coincidencia null , se devuelve. binderIf the binder is unable to select a match, then null is returned.

Se pueden BindingFlags usar las siguientes marcas de filtro para definir los constructores que se van a incluir en la búsqueda:The following BindingFlags filter flags can be used to define which constructors to include in the search:

  • Debe especificar BindingFlags.Instance o BindingFlags.Static para obtener un valor devuelto.You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.

  • Especifique BindingFlags.Public para incluir constructores públicos en la búsqueda.Specify BindingFlags.Public to include public constructors in the search.

  • Especifique BindingFlags.NonPublic para incluir constructores no públicos (es decir, constructores privados, internos y protegidos) en la búsqueda.Specify BindingFlags.NonPublic to include non-public constructors (that is, private, internal, and protected constructors) in the search.

Vea System.Reflection.BindingFlags para obtener más información.See System.Reflection.BindingFlags for more information.

Para obtener el inicializador de clase (constructor estático) mediante esta sobrecarga del método, debe BindingFlags.Static especificarBindingFlags.Static | BindingFlags.NonPublic (Or BindingFlags.NonPublic en Visual Basic).To get the class initializer (static constructor) using this method overload, you must specify BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.StaticOrBindingFlags.NonPublic in Visual Basic). También puede obtener el inicializador de clase mediante la TypeInitializer propiedad.You can also get the class initializer using the TypeInitializer property.

Nota

No se pueden omitir los parámetros al buscar constructores y métodos.You cannot omit parameters when looking up constructors and methods. Solo se pueden omitir los parámetros al invocar a.You can only omit parameters when invoking.

Si el actual Type representa un tipo genérico construido, este método ConstructorInfo devuelve con los parámetros de tipo reemplazados por los argumentos de tipo adecuados.If the current Type represents a constructed generic type, this method returns the ConstructorInfo with the type parameters replaced by the appropriate type arguments. Si el actual Type representa un parámetro de tipo en la definición de un tipo genérico o de un método genérico, este nullmétodo siempre devuelve.If the current Type represents a type parameter in the definition of a generic type or generic method, this method always returns null.

Consulte también:

GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Busca un constructor cuyos parámetros coincidan con los modificadores y tipos de argumento especificados, mediante las restricciones de enlace indicadas y la convención de llamadas también especificada.Searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

public:
 virtual System::Reflection::ConstructorInfo ^ GetConstructor(System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, System::Reflection::CallingConventions callConvention, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
[System.Runtime.InteropServices.ComVisible(true)]
public System.Reflection.ConstructorInfo GetConstructor (System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Reflection.CallingConventions callConvention, Type[] types, System.Reflection.ParameterModifier[] modifiers);
abstract member GetConstructor : System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.ConstructorInfo
override this.GetConstructor : System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.ConstructorInfo

Parámetros

bindingAttr
BindingFlags

Combinación bit a bit de los valores de enumeración que especifican cómo se realiza la búsqueda.A bitwise combination of the enumeration values that specify how the search is conducted.

O bien-or- Default para devolver null.Default to return null.

binder
Binder

Objeto que define un conjunto de propiedades y permite realizar operaciones de enlace, que pueden incluir la selección de un método sobrecargado, la coerción de tipos de argumentos y la invocación de un miembro mediante reflexión.An object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

O bien-or- Referencia nula (Nothing en Visual Basic) para usar la propiedad DefaultBinder.A null reference (Nothing in Visual Basic), to use the DefaultBinder.

callConvention
CallingConventions

Objeto que especifica el conjunto de reglas que se va a usar en cuanto al orden y al diseño de los argumentos, la forma de pasar el valor devuelto, los registros que se usan para los argumentos y la pila que se limpia.The object that specifies the set of rules to use regarding the order and layout of arguments, how the return value is passed, what registers are used for arguments, and the stack is cleaned up.

types
Type[]

Matriz de objetos Type que representa el número, el orden y el tipo de parámetros que el constructor debe obtener.An array of Type objects representing the number, order, and type of the parameters for the constructor to get.

o bien-or- Matriz vacía del tipo Type (es decir, Type[] types = new Type[0]) para obtener un constructor que no requiera parámetros.An empty array of the type Type (that is, Type[] types = new Type[0]) to get a constructor that takes no parameters.

modifiers
ParameterModifier[]

Matriz de objetos ParameterModifier que representan los atributos asociados al elemento correspondiente de la matriz types.An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. El enlazador predeterminado no procesa este parámetro.The default binder does not process this parameter.

Devoluciones

Objeto que representa el constructor que cumple los requisitos especificados, si se encuentra; en caso contrario, es null.An object representing the constructor that matches the specified requirements, if found; otherwise, null.

Implementaciones

Atributos

Excepciones

types es null.types is null.

o bien-or- Uno de los elementos de types es null.One of the elements in types is null.

types es multidimensional.types is multidimensional.

O bien-or- modifiers es multidimensional.modifiers is multidimensional.

o bien-or- types y modifiers no tienen la misma longitud.types and modifiers do not have the same length.

Ejemplos

En el ejemplo siguiente se obtiene el tipo MyClass1de, se ConstructorInfo obtiene el objeto que coincide con las marcas de enlace especificadas y se muestra la firma del constructor.The following example obtains the type of MyClass1, gets the ConstructorInfo object that matches the specified binding flags, and displays the constructor signature.

using namespace System;
using namespace System::Reflection;
using namespace System::Security;
public ref class MyClass1
{
public:
   MyClass1( int i ){}

};

int main()
{
   try
   {
      Type^ myType = MyClass1::typeid;
      array<Type^>^types = gcnew array<Type^>(1);
      types[ 0 ] = int::typeid;
      
      // Get the public instance constructor that takes an integer parameter.
      ConstructorInfo^ constructorInfoObj = myType->GetConstructor( static_cast<BindingFlags>(BindingFlags::Instance | BindingFlags::Public), nullptr, CallingConventions::HasThis, types, nullptr );
      if ( constructorInfoObj != nullptr )
      {
         Console::WriteLine( "The constructor of MyClass1 that is a public instance method and takes an integer as a parameter is: " );
         Console::WriteLine( constructorInfoObj );
      }
      else
      {
         Console::WriteLine( "The constructor of MyClass1 that is a public instance method and takes an integer as a parameter is not available." );
      }
   }
   catch ( ArgumentNullException^ e ) 
   {
      Console::WriteLine( "ArgumentNullException: {0}", e->Message );
   }
   catch ( ArgumentException^ e ) 
   {
      Console::WriteLine( "ArgumentException: {0}", e->Message );
   }
   catch ( SecurityException^ e ) 
   {
      Console::WriteLine( "SecurityException: {0}", e->Message );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: {0}", e->Message );
   }
}
using System;
using System.Reflection;
using System.Security;

public class MyClass1
{
    public MyClass1(int i){}
    public static void Main()
    {
        try
        {
            Type  myType = typeof(MyClass1);
            Type[] types = new Type[1];
            types[0] = typeof(int);
            // Get the public instance constructor that takes an integer parameter.
            ConstructorInfo constructorInfoObj = myType.GetConstructor(
                BindingFlags.Instance | BindingFlags.Public, null,
                CallingConventions.HasThis, types, null);
            if(constructorInfoObj != null)
            {
                Console.WriteLine("The constructor of MyClass1 that is a public " +
                    "instance method and takes an integer as a parameter is: ");
                Console.WriteLine(constructorInfoObj.ToString());
            }
            else
            {
                Console.WriteLine("The constructor of MyClass1 that is a public instance " +
                    "method and takes an integer as a parameter is not available.");
            }
        }
        catch(ArgumentNullException e)
        {
            Console.WriteLine("ArgumentNullException: " + e.Message);
        }
        catch(ArgumentException e)
        {
            Console.WriteLine("ArgumentException: " + e.Message);
        }
        catch(SecurityException e)
        {
            Console.WriteLine("SecurityException: " + e.Message);
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception: " + e.Message);
        }
    }
}
Public Class MyClass1
    Public Sub New(ByVal i As Integer)
    End Sub
    Public Shared Sub Main()
        Try
            Dim myType As Type = GetType(MyClass1)
            Dim types(0) As Type
            types(0) = GetType(Integer)
            ' Get the public instance constructor that takes an integer parameter.
            Dim constructorInfoObj As ConstructorInfo = _
                        myType.GetConstructor(BindingFlags.Instance Or _
                        BindingFlags.Public, Nothing, _
                        CallingConventions.HasThis, types, Nothing)
            If Not (constructorInfoObj Is Nothing) Then
                Console.WriteLine("The constructor of MyClass1 that " + _
                                  "is a public instance method and takes an " + _
                                  "integer as a parameter is: ")
                Console.WriteLine(constructorInfoObj.ToString())
            Else
                Console.WriteLine("The constructor MyClass1 that " + _
                                  "is a public instance method and takes an " + _
                                  "integer as a parameter is not available.")
            End If
        Catch e As ArgumentNullException
            Console.WriteLine("ArgumentNullException: " + e.Message)
        Catch e As ArgumentException
            Console.WriteLine("ArgumentException: " + e.Message)
        Catch e As SecurityException
            Console.WriteLine("SecurityException: " + e.Message)
        Catch e As Exception
            Console.WriteLine("Exception: " + e.Message)
        End Try
    End Sub
End Class

Comentarios

Aunque ParameterModifier el enlazador predeterminado no procesa (el modifiers parámetro), puede usar la clase abstracta System.Reflection.Binder para escribir un enlazador personalizado que realice el proceso modifiers.Although the default binder does not process ParameterModifier (the modifiers parameter), you can use the abstract System.Reflection.Binder class to write a custom binder that does process modifiers. ParameterModifiersolo se usa cuando se llama a través de la interoperabilidad COM y solo se controlan los parámetros que se pasan por referencia.ParameterModifier is only used when calling through COM interop, and only parameters that are passed by reference are handled.

Si no existe una coincidencia exacta, binder intentará convertir los tipos de parámetro especificados en la types matriz para seleccionar una coincidencia.If an exact match does not exist, the binder will attempt to coerce the parameter types specified in the types array in order to select a match. Si no puede seleccionar una coincidencia null , se devuelve. binderIf the binder is unable to select a match, then null is returned.

Se pueden BindingFlags usar las siguientes marcas de filtro para definir los constructores que se van a incluir en la búsqueda:The following BindingFlags filter flags can be used to define which constructors to include in the search:

  • Debe especificar BindingFlags.Instance o BindingFlags.Static para obtener un valor devuelto.You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.

  • Especifique BindingFlags.Public para incluir constructores públicos en la búsqueda.Specify BindingFlags.Public to include public constructors in the search.

  • Especifique BindingFlags.NonPublic para incluir constructores no públicos (es decir, constructores privados, internos y protegidos) en la búsqueda.Specify BindingFlags.NonPublic to include non-public constructors (that is, private, internal, and protected constructors) in the search.

Vea System.Reflection.BindingFlags para obtener más información.See System.Reflection.BindingFlags for more information.

Para obtener el inicializador de clase (constructor estático) con este método, debe especificar BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.Static Or BindingFlags.NonPublic en Visual Basic).To get the class initializer (static constructor) using this method, you must specify BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.StaticOrBindingFlags.NonPublic in Visual Basic). También puede obtener el inicializador de clase mediante la TypeInitializer propiedad.You can also get the class initializer using the TypeInitializer property.

En la tabla siguiente se muestra qué miembros de una clase base son devueltos por los Get métodos cuando se reflejan en un tipo.The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Tipo de miembroMember Type EstáticoStatic No estáticaNon-Static
ConstructorConstructor NoNo NoNo
CampoField NoNo Sí.Yes. Un campo siempre se oculta por nombre y firma.A field is always hide-by-name-and-signature.
eventoEvent No es aplicableNot applicable La regla del sistema de tipos comunes es que la herencia es la misma que la de los métodos que implementan la propiedad.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflexión trata las propiedades como ocultas por nombre y firma.Reflection treats properties as hide-by-name-and-signature. Vea la nota 2 a continuación.See note 2 below.
MétodoMethod NoNo Sí.Yes. Un método (tanto virtual como no virtual) se puede ocultar por nombre u ocultar por nombre y por firma.A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Tipo anidadoNested Type NoNo NoNo
Propiedad.Property No es aplicableNot applicable La regla del sistema de tipos comunes es que la herencia es la misma que la de los métodos que implementan la propiedad.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflexión trata las propiedades como ocultas por nombre y firma.Reflection treats properties as hide-by-name-and-signature. Vea la nota 2 a continuación.See note 2 below.
  1. Ocultar por nombre y firma tiene en cuenta todas las partes de la firma, incluidos los modificadores personalizados, los tipos de valor devuelto, los tipos de parámetros, los Sentinel y las convenciones de llamada no administradas.Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. Esta es una comparación binaria.This is a binary comparison.

  2. En la reflexión, las propiedades y los eventos son Hide-by-Name y Signature.For reflection, properties and events are hide-by-name-and-signature. Si tiene una propiedad con un descriptor de acceso get y set en la clase base, pero la clase derivada solo tiene un descriptor de acceso get, la propiedad de la clase derivada oculta la propiedad de clase base y no podrá tener acceso al establecedor en la clase base.If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.

  3. Los atributos personalizados no forman parte del sistema de tipos comunes.Custom attributes are not part of the common type system.

Nota

No se pueden omitir los parámetros al buscar constructores y métodos.You cannot omit parameters when looking up constructors and methods. Solo se pueden omitir los parámetros al invocar a.You can only omit parameters when invoking.

Si el actual Type representa un tipo genérico construido, este método ConstructorInfo devuelve con los parámetros de tipo reemplazados por los argumentos de tipo adecuados.If the current Type represents a constructed generic type, this method returns the ConstructorInfo with the type parameters replaced by the appropriate type arguments. Si el actual Type representa un parámetro de tipo en la definición de un tipo genérico o de un método genérico, este nullmétodo siempre devuelve.If the current Type represents a type parameter in the definition of a generic type or generic method, this method always returns null.

Consulte también:

Se aplica a