Type.GetConstructor Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Obtient un constructeur spécifique du Type actuel.

Surcharges

GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Recherche un constructeur dont les paramètres correspondent aux types d’arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison et la convention d’appel indiquées.
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Recherche un constructeur dont les paramètres correspondent aux types d’arguments et modificateurs spécifiés, à l’aide des contraintes de liaison spécifiées.
GetConstructor(BindingFlags, Type[])	Recherche un constructeur dont les paramètres correspondent aux types d’arguments spécifiés, à l’aide des contraintes de liaison spécifiées.
GetConstructor(Type[])	Recherche un constructeur d'instance public dont les paramètres correspondent aux types contenus dans le tableau spécifié.

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

Source:

Type.cs

Recherche un constructeur dont les paramètres correspondent aux types d’arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison et la convention d’appel indiquées.

public:
 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);

public System.Reflection.ConstructorInfo? GetConstructor (System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, System.Reflection.CallingConventions callConvention, Type[] types, System.Reflection.ParameterModifier[]? modifiers);

member this.GetConstructor : System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.ConstructorInfo

Public Function GetConstructor (bindingAttr As BindingFlags, binder As Binder, callConvention As CallingConventions, types As Type(), modifiers As ParameterModifier()) As ConstructorInfo

Paramètres

bindingAttr

BindingFlags

Combinaison de bits de valeurs d’énumération qui spécifie la façon dont est effectuée la recherche.

- ou -

Default pour retourner null.

binder

Binder

Objet qui définit un ensemble de propriétés et permet la liaison, ce qui peut impliquer la sélection d'une méthode surchargée, la contrainte de types d'arguments et l'appel d'un membre par la réflexion.

- ou -

Référence null (Nothing en Visual Basic) pour utiliser DefaultBinder.

callConvention

CallingConventions

Objet qui spécifie l’ensemble de règles à utiliser en ce qui concerne l’ordre et la disposition des arguments, la manière dont la valeur de retour est passée, les registres utilisés pour les arguments et la manière dont la pile est nettoyée.

types

Type[]

Tableau d'objets Type représentant le nombre, l'ordre et le type des paramètres du constructeur à obtenir.

- ou -

Tableau vide de type Type (c'est-à-dire Type[] types = new Type[0]) pour obtenir un constructeur qui ne prend aucun paramètre.

modifiers

ParameterModifier[]

Tableau d'objets ParameterModifier représentant les attributs associés à l'élément correspondant dans le tableau types. Le binder par défaut ne traite pas ce paramètre.

Retours

ConstructorInfo

Objet représentant le constructeur qui correspond aux exigences spécifiées, s’il est trouvé ; sinon, null.

Exceptions

ArgumentNullException

types a la valeur null.

- ou -

Un des éléments de types est null.

ArgumentException

types est multidimensionnel.

- ou -

modifiers est multidimensionnel.

- ou -

types et modifiers n’ont pas la même longueur.

Exemples

L’exemple suivant obtient le type de MyClass, obtient l’objet ConstructorInfo et affiche la signature du constructeur.

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 MyClass3
{
    public MyClass3(int i) { }
    public static void Main()
    {
        try
        {
            Type myType = typeof(MyClass3);
            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 MyClass3 that is a public " +
                    "instance method and takes an integer as a parameter is: ");
                Console.WriteLine(constructorInfoObj.ToString());
            }
            else
            {
                Console.WriteLine("The constructor of MyClass3 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);
        }
    }
}

open System
open System.Reflection
open System.Security

type MyClass1(i: int) = class end

try
    let myType = typeof<MyClass1>
    let types = [| typeof<int> |]
    // Get the public instance constructor that takes an integer parameter.
    let constructorInfoObj = myType.GetConstructor(BindingFlags.Instance ||| BindingFlags.Public, null, CallingConventions.HasThis, types, null)
    if constructorInfoObj <> null then
        printfn "The constructor of MyClass1 that is a public instance method and takes an integer as a parameter is: \n{constructorInfoObj}"
    else
        printfn "The constructor of MyClass1 that is a public instance method and takes an integer as a parameter is not available."
with
| :? ArgumentNullException as e ->
    printfn $"ArgumentNullException: {e.Message}"
| :? ArgumentException as e ->
    printfn $"ArgumentException: {e.Message}"
| :? SecurityException as e ->
    printfn $"SecurityException: {e.Message}"
| e ->
    printfn $"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

Remarques

Bien que le classeur par défaut ne traite ParameterModifier pas (le modifiers paramètre), vous pouvez utiliser la classe abstraite System.Reflection.Binder pour écrire un classeur personnalisé qui traite modifiers. ParameterModifier est utilisé uniquement lors de l’appel via l’interopérabilité COM, et seuls les paramètres passés par référence sont gérés.

S’il n’existe pas de correspondance exacte, le binder tente de forcer les types de paramètres spécifiés dans le types tableau afin de sélectionner une correspondance. Si le binder n’est pas en mesure de sélectionner une correspondance, il null est retourné.

Les indicateurs de filtre suivants BindingFlags peuvent être utilisés pour définir les constructeurs à inclure dans la recherche :

• Vous devez spécifier ou BindingFlags.InstanceBindingFlags.Static pour obtenir un retour.

• Spécifiez BindingFlags.Public pour inclure des constructeurs publics dans la recherche.

• Spécifiez BindingFlags.NonPublic d’inclure des constructeurs non publics (c’est-à-dire des constructeurs privés, internes et protégés) dans la recherche.

Consultez la rubrique System.Reflection.BindingFlags (éventuellement en anglais) pour plus d'informations.

Pour obtenir l’initialiseur de classe (constructeur statique) à l’aide de cette méthode, vous devez spécifier BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.StaticOrBindingFlags.NonPublic en Visual Basic). Vous pouvez également obtenir l’initialiseur de classe à l’aide de la TypeInitializer propriété .

Le tableau suivant montre quels membres d’une classe de base sont retournés par les méthodes lors de la Get réflexion sur un type.

Type de membre	statique	Non statique
Constructeur	Non	Non
Champ	Non	Oui. Un champ est toujours masqué par nom et signature.
Événement	Non applicable	La règle système de type courante est que l’héritage est le même que celui des méthodes qui implémentent la propriété. Reflection traite les propriétés comme masquer par nom et signature. Voir la note 2 ci-dessous.
Méthode	Non	Oui. Une méthode (virtuelle et non virtuelle) peut être hide-by-name ou hide-by-name-and-signature.
Type imbriqué	Non	Non
Propriété	Non applicable	La règle système de type courante est que l’héritage est le même que celui des méthodes qui implémentent la propriété. Reflection traite les propriétés comme masquer par nom et signature. Voir la note 2 ci-dessous.

1. Masquer par nom et signature prend en compte toutes les parties de la signature, y compris les modificateurs personnalisés, les types de retour, les types de paramètres, les sentinelles et les conventions d’appel non managées. Il s’agit d’une comparaison binaire.

2. Pour la réflexion, les propriétés et les événements sont masqués par nom-et-signature. Si vous avez une propriété avec un accesseur get et un accesseur set dans la classe de base, mais que la classe dérivée n’a qu’un accesseur get, la propriété de classe dérivée masque la propriété de classe de base et vous ne pourrez pas accéder au setter sur la classe de base.

3. Les attributs personnalisés ne font pas partie du système de type commun.

Notes

Vous ne pouvez pas omettre des paramètres lors de la recherche de constructeurs et de méthodes. Vous pouvez uniquement omettre des paramètres lors de l’appel.

Si le courant Type représente un type générique construit, cette méthode retourne le ConstructorInfo avec les paramètres de type remplacés par les arguments de type appropriés. Si le actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode retourne nulltoujours .

Voir aussi

• ConstructorInfo
• BindingFlags
• Binder
• DefaultBinder
• CallingConventions
• ParameterModifier
• GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
• GetConstructors()

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

Source:

Type.cs

Recherche un constructeur dont les paramètres correspondent aux types d’arguments et modificateurs spécifiés, à l’aide des contraintes de liaison spécifiées.

public:
 System::Reflection::ConstructorInfo ^ GetConstructor(System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);

public System.Reflection.ConstructorInfo? GetConstructor (System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, Type[] types, System.Reflection.ParameterModifier[]? modifiers);

member this.GetConstructor : System.Reflection.BindingFlags * System.Reflection.Binder * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.ConstructorInfo

Public Function GetConstructor (bindingAttr As BindingFlags, binder As Binder, types As Type(), modifiers As ParameterModifier()) As ConstructorInfo

Paramètres

bindingAttr

BindingFlags

Combinaison de bits de valeurs d’énumération qui spécifie la façon dont est effectuée la recherche.

- ou -

Default pour retourner null.

binder

Binder

Objet qui définit un ensemble de propriétés et permet la liaison, ce qui peut impliquer la sélection d'une méthode surchargée, la contrainte de types d'arguments et l'appel d'un membre par la réflexion.

- ou -

Référence null (Nothing en Visual Basic) pour utiliser DefaultBinder.

types

Type[]

Tableau d'objets Type représentant le nombre, l'ordre et le type des paramètres du constructeur à obtenir.

- ou -

Tableau vide de type Type (c'est-à-dire Type[] types = new Type[0]) pour obtenir un constructeur qui ne prend aucun paramètre.

- ou -

EmptyTypes.

modifiers

ParameterModifier[]

Tableau d'objets ParameterModifier représentant les attributs associés à l'élément correspondant dans le tableau de types de paramètres. Le binder par défaut ne traite pas ce paramètre.

Retours

ConstructorInfo

Objet ConstructorInfo qui représente le constructeur correspondant aux critères spécifiés, s'il existe ; sinon, null.

Exceptions

ArgumentNullException

types a la valeur null.

- ou -

Un des éléments de types est null.

ArgumentException

types est multidimensionnel.

- ou -

modifiers est multidimensionnel.

- ou -

types et modifiers n’ont pas la même longueur.

Exemples

L’exemple suivant obtient le type de MyClass, obtient l’objet ConstructorInfo et affiche la signature du constructeur.

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 MyClass2
{
    public MyClass2(int i) { }
    public static void Main()
    {
        try
        {
            Type myType = typeof(MyClass2);
            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 MyClass2 that is public " +
                    "and takes an integer as a parameter is:");
                Console.WriteLine(constructorInfoObj.ToString());
            }
            else
            {
                Console.WriteLine("The constructor of the MyClass2 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);
        }
    }
}

open System
open System.Reflection
open System.Security

type MyClass1(i: int) = class end

try
    let myType = typeof<MyClass1>
    let types = [| typeof<int> |]
    // Get the constructor that is public and takes an integer parameter.
    let constructorInfoObj = myType.GetConstructor(BindingFlags.Instance ||| BindingFlags.Public, null, types, null)
    if constructorInfoObj <> null then
        printfn "The constructor of MyClass1 that is public and takes an integer as a parameter is:\n{constructorInfoObj}"
    else
        printfn "The constructor of the MyClass1 that is public and takes an integer as a parameter is not available."
with
| :? ArgumentNullException as e ->
    printfn $"ArgumentNullException: {e.Message}"
| :? ArgumentException as e ->
    printfn $"ArgumentException: {e.Message}"
| :? SecurityException as e ->
    printfn $"SecurityException: {e.Message}"
| e ->
    printfn $"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

Remarques

S’il n’existe pas de correspondance exacte, le binder tente de contraindre les types de paramètres spécifiés dans le types tableau afin de sélectionner une correspondance. Si ne binder parvient pas à sélectionner une correspondance, null est retourné.

Les indicateurs de filtre suivants BindingFlags peuvent être utilisés pour définir les constructeurs à inclure dans la recherche :

• Vous devez spécifier ou BindingFlags.InstanceBindingFlags.Static pour obtenir un retour.

• Spécifiez BindingFlags.Public pour inclure des constructeurs publics dans la recherche.

• Spécifiez BindingFlags.NonPublic pour inclure des constructeurs non publics (c’est-à-dire des constructeurs privés, internes et protégés) dans la recherche.

Consultez la rubrique System.Reflection.BindingFlags (éventuellement en anglais) pour plus d'informations.

Pour obtenir l’initialiseur de classe (constructeur statique) à l’aide de cette surcharge de méthode, vous devez spécifier BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.StaticOrBindingFlags.NonPublic en Visual Basic). Vous pouvez également obtenir l’initialiseur de classe à l’aide de la TypeInitializer propriété .

Notes

Vous ne pouvez pas omettre des paramètres lors de la recherche de constructeurs et de méthodes. Vous ne pouvez omettre des paramètres que lors de l’appel.

Si le actuel Type représente un type générique construit, cette méthode retourne le ConstructorInfo avec les paramètres de type remplacés par les arguments de type appropriés. Si le actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode retourne nulltoujours .

Voir aussi

• ConstructorInfo
• BindingFlags
• Binder
• DefaultBinder
• ParameterModifier
• GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
• GetConstructors()

GetConstructor(BindingFlags, Type[])

Source:

Type.cs

Recherche un constructeur dont les paramètres correspondent aux types d’arguments spécifiés, à l’aide des contraintes de liaison spécifiées.

public:
 System::Reflection::ConstructorInfo ^ GetConstructor(System::Reflection::BindingFlags bindingAttr, cli::array <Type ^> ^ types);

public System.Reflection.ConstructorInfo? GetConstructor (System.Reflection.BindingFlags bindingAttr, Type[] types);

member this.GetConstructor : System.Reflection.BindingFlags * Type[] -> System.Reflection.ConstructorInfo

Public Function GetConstructor (bindingAttr As BindingFlags, types As Type()) As ConstructorInfo

Paramètres

bindingAttr

BindingFlags

Combinaison de bits de valeurs d’énumération qui spécifie la façon dont est effectuée la recherche. - ou - Valeur par défaut pour retourner null.

types

Type[]

Tableau d’objets Type représentant le nombre, l’ordre et le type des paramètres que le constructeur doit obtenir. -ou- Tableau vide du type Type (c’est-à-dire, Type[] types = Array.Empty{Type}()) pour obtenir un constructeur qui ne prend aucun paramètre. -ou- EmptyTypes.

Retours

ConstructorInfo

Objet ConstructorInfo qui représente le constructeur correspondant aux critères spécifiés, s'il existe ; sinon, null.

GetConstructor(Type[])

Source:

Type.cs

Recherche un constructeur d'instance public dont les paramètres correspondent aux types contenus dans le tableau spécifié.

public:
 System::Reflection::ConstructorInfo ^ GetConstructor(cli::array <Type ^> ^ types);

public System.Reflection.ConstructorInfo? GetConstructor (Type[] types);

member this.GetConstructor : Type[] -> System.Reflection.ConstructorInfo

Public Function GetConstructor (types As Type()) As ConstructorInfo

Paramètres

types

Type[]

Tableau d'objets Type représentant le nombre, l'ordre et le type des paramètres du constructeur souhaité.

- ou -

Tableau vide d'objets Type pour obtenir un constructeur n'acceptant aucun paramètre. Un tel tableau vide est fourni par le champ staticEmptyTypes.

Retours

ConstructorInfo

Objet représentant le constructeur d'instance public dont les paramètres correspondent aux types contenus dans le tableau de types de paramètres, s'il est trouvé ; sinon, null.

Exceptions

ArgumentNullException

types a la valeur null.

- ou -

Un des éléments de types est null.

ArgumentException

types est multidimensionnel.

Exemples

L’exemple suivant obtient le type de MyClass, obtient l’objet ConstructorInfo et affiche la signature du constructeur.

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;

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);
        }
    }
}

type MyClass1() =
    new (i: int) = MyClass1()

try
    let myType = typeof<MyClass1>
    let types = [| typeof<int> |]
    // Get the constructor that takes an integer as a parameter.
    let constructorInfoObj = myType.GetConstructor types
    if constructorInfoObj <> null then
        printfn "The constructor of MyClass1 that takes an integer as a parameter is: \n{constructorInfoObj}"
    else
        printfn "The constructor of MyClass1 that takes an integer as a parameter is not available."
with e ->
    printfn "Exception caught."
    printfn $"Source: {e.Source}"
    printfn $"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

Remarques

Cette surcharge de méthode recherche des constructeurs instance publics et ne peut pas être utilisée pour obtenir un initialiseur de classe (constructeur statique). Pour obtenir un initialiseur de classe, utilisez une surcharge qui prend BindingFlags, et spécifiez | BindingFlags.NonPublicBindingFlags.Static(BindingFlags.StaticOrBindingFlags.NonPublic en Visual Basic). Vous pouvez également obtenir l’initialiseur de classe à l’aide de la TypeInitializer propriété .

Si le constructeur demandé n’est pas public, cette méthode retourne null.

Notes

Vous ne pouvez pas omettre des paramètres lors de la recherche de constructeurs et de méthodes. Vous ne pouvez omettre des paramètres que lors de l’appel.

Si le actuel Type représente un type générique construit, cette méthode retourne le ConstructorInfo avec les paramètres de type remplacés par les arguments de type appropriés. Si le actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode retourne nulltoujours .

Voir aussi

• ConstructorInfo
• DefaultBinder
• GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
• GetConstructors()