Type.GetConstructor Methode

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Ruft einen bestimmten Konstruktor des aktuellen Type ab.

Überlädt

GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Sucht einen Konstruktor, dessen Parameter den angegebenen Argumenttypen und -modifizierern entsprechen, und berücksichtigt dabei die angegebenen Bindungseinschränkungen und die angegebene Aufrufkonvention.
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Sucht einen Konstruktor, dessen Parameter unter Verwendung der angegebenen Bindungseinschränkungen den angegebenen Argumenttypen und -modifizierern entsprechen.
GetConstructor(BindingFlags, Type[])	Sucht unter Verwendung der angegebenen Bindungseinschränkungen nach einem Konstruktor, dessen Parameter mit den angegebenen Argumenttypen übereinstimmen.
GetConstructor(Type[])	Sucht einen öffentlichen Instanzkonstruktor, dessen Parameter den Typen im angegebenen Array entsprechen.

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

Quelle:

Type.cs

Sucht einen Konstruktor, dessen Parameter den angegebenen Argumenttypen und -modifizierern entsprechen, und berücksichtigt dabei die angegebenen Bindungseinschränkungen und die angegebene Aufrufkonvention.

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

Parameter

bindingAttr

BindingFlags

Eine bitweise Kombination der Enumerationswerte, die angeben, wie die Suche durchgeführt wird.

- oder -

Default, damit null zurückgegeben wird.

binder

Binder

Ein Objekt, das eine Gruppe von Eigenschaften definiert und eine Bindung ermöglicht. Dazu kann die Auswahl einer überladenen Methode, die Umwandlung von Argumenttypen und der Aufruf eines Members durch Reflektion gehören.

- oder -

Ein Nullverweis (Nothing in Visual Basic), wenn DefaultBinder verwendet werden soll.

callConvention

CallingConventions

Das Objekt, das die Regeln für die Reihenfolge und das Layout von Argumenten, die Art der Übergabe des Rückgabewerts, die für Argumente zu verwendenden Register und die Art der Stapelbereinigung angibt.

types

Type[]

Ein Array von Type-Objekten, das Anzahl, Reihenfolge und Typ der Parameter des abzurufenden Konstruktors darstellt.

- oder -

Ein leeres Array vom Type-Typ, d. h. Type[] types = new Type[0], zum Abrufen eines Konstruktors, der keine Parameter akzeptiert.

modifiers

ParameterModifier[]

Ein Array von ParameterModifier-Objekten, die die Attribute darstellen, die dem entsprechenden Element im types-Array zugeordnet sind. Der Standardbinder verarbeitet diesen Parameter nicht.

Gibt zurück

ConstructorInfo

Ein Objekt, das den Konstruktor darstellt, der den angegebenen Anforderungen entspricht, sofern gefunden, andernfalls null.

Ausnahmen

ArgumentNullException

types ist null.

- oder -

Eines der Elemente in types ist null.

ArgumentException

types ist mehrdimensional.

- oder -

modifiers ist mehrdimensional.

- oder -

types und modifiers weisen nicht die gleiche Länge auf.

Beispiele

Im folgenden Beispiel wird der Typ von MyClassabgerufen, das ConstructorInfo -Objekt abgerufen und die Konstruktorsignatur angezeigt.

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

Hinweise

Obwohl der Standardbinder (den modifiers -Parameter) nicht verarbeitet ParameterModifier , können Sie die abstrakte System.Reflection.Binder Klasse verwenden, um einen benutzerdefinierten Binder zu schreiben, der verarbeitetmodifiers. ParameterModifier wird nur beim Aufrufen über COM-Interop verwendet, und nur Parameter, die als Verweis übergeben werden, werden behandelt.

Wenn keine genaue Übereinstimmung vorhanden ist, versucht der binder , die im types Array angegebenen Parametertypen zu ermärigen, um eine Übereinstimmung auszuwählen. Wenn keine binder Übereinstimmung ausgewählt werden kann, wird zurückgegeben null .

Die folgenden BindingFlags Filterflags können verwendet werden, um zu definieren, welche Konstruktoren in die Suche einbezogen werden sollen:

• Sie müssen entweder BindingFlags.Instance oder BindingFlags.Static angeben, um eine Rückgabe zu erhalten.

• Geben Sie an BindingFlags.Public , dass öffentliche Konstruktoren in die Suche einbezogen werden sollen.

• Geben Sie an BindingFlags.NonPublic , dass nicht öffentliche Konstruktoren (d. h. private, interne und geschützte Konstruktoren) in die Suche einbezogen werden sollen.

Weitere Informationen finden Sie unter System.Reflection.BindingFlags.

Um den Klasseninitialisierer (statischer Konstruktor) mithilfe dieser Methode abzurufen, müssen Sie (OrBindingFlags.NonPublicBindingFlags.Static in Visual Basic) angeben.BindingFlags.Static | BindingFlags.NonPublic Sie können den Klasseninitialisierer auch mithilfe der TypeInitializer -Eigenschaft abrufen.

Die folgende Tabelle zeigt, welche Member einer Basisklasse von den Get Methoden zurückgegeben werden, wenn sie einen Typ reflektieren.

Memberart	statischen	Nicht statisch
Konstruktor	Nein	Nein
Feld	Nein	Ja. Ein Feld wird immer nach Name und Signatur ausgeblendet.
Ereignis	Nicht zutreffend	Die allgemeine Typsystemregel ist, dass die Vererbung mit der der Methoden identisch ist, die die -Eigenschaft implementieren. Reflektion behandelt Eigenschaften als Hide-by-Name-and-Signature. Siehe Hinweis 2 unten.
Methode	Nein	Ja. Eine Methode (sowohl virtuell als auch nicht virtuell) kann hide-by-name oder hide-by-name-and-signature sein.
Geschachtelter Typ	Nein	Nein
Eigenschaft	Nicht zutreffend	Die allgemeine Typsystemregel ist, dass die Vererbung mit der der Methoden identisch ist, die die -Eigenschaft implementieren. Reflektion behandelt Eigenschaften als Hide-by-Name-and-Signature. Siehe Hinweis 2 unten.

1. Hide-by-Name-and-signature berücksichtigt alle Teile der Signatur, einschließlich benutzerdefinierter Modifizierer, Rückgabetypen, Parametertypen, Sentinels und nicht verwalteter Aufrufkonventionen. Dies ist ein binärer Vergleich.

2. Für die Reflektion werden Eigenschaften und Ereignisse nach Name und Signatur ausgeblendet. Wenn Sie über eine Eigenschaft mit einem get- und einem Set-Accessor in der Basisklasse verfügen, die abgeleitete Klasse jedoch nur über einen Get-Accessor verfügt, blendet die abgeleitete Klasseneigenschaft die Basisklasseeigenschaft aus, und Sie können nicht auf den Setter für die Basisklasse zugreifen.

3. Benutzerdefinierte Attribute sind nicht Teil des allgemeinen Typsystems.

Hinweis

Sie können Parameter beim Suchen nach Konstruktoren und Methoden nicht weglassen. Sie können Parameter nur beim Aufrufen weglassen.

Wenn der aktuelle einen konstruierten generischen Type Typ darstellt, gibt diese Methode den ConstructorInfo zurück, wobei die Typparameter durch die entsprechenden Typargumente ersetzt werden. Wenn der aktuelle einen Typparameter in der Definition eines generischen Typs oder einer generischen Type Methode darstellt, gibt diese Methode immer zurück null.

Weitere Informationen

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

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

Quelle:

Type.cs

Sucht einen Konstruktor, dessen Parameter unter Verwendung der angegebenen Bindungseinschränkungen den angegebenen Argumenttypen und -modifizierern entsprechen.

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

Parameter

bindingAttr

BindingFlags

Eine bitweise Kombination der Enumerationswerte, die angeben, wie die Suche durchgeführt wird.

- oder -

Default, damit null zurückgegeben wird.

binder

Binder

Ein Objekt, das eine Gruppe von Eigenschaften definiert und eine Bindung ermöglicht. Dazu kann die Auswahl einer überladenen Methode, die Umwandlung von Argumenttypen und der Aufruf eines Members durch Reflektion gehören.

- oder -

Ein Nullverweis (Nothing in Visual Basic), wenn DefaultBinder verwendet werden soll.

types

Type[]

Ein Array von Type-Objekten, das Anzahl, Reihenfolge und Typ der Parameter des abzurufenden Konstruktors darstellt.

- oder -

Ein leeres Array vom Type-Typ, d. h. Type[] types = new Type[0], zum Abrufen eines Konstruktors, der keine Parameter akzeptiert.

- oder -

EmptyTypes.

modifiers

ParameterModifier[]

Ein Array von ParameterModifier-Objekten, die die Attribute darstellen, die dem entsprechenden Element im Parametertyparray zugeordnet sind. Der Standardbinder verarbeitet diesen Parameter nicht.

Gibt zurück

ConstructorInfo

Ein ConstructorInfo-Objekt, das den Konstruktor darstellt, der den angegebenen Anforderungen entspricht, oder null, wenn kein entsprechender Konstruktor gefunden wurde.

Ausnahmen

ArgumentNullException

types ist null.

- oder -

Eines der Elemente in types ist null.

ArgumentException

types ist mehrdimensional.

- oder -

modifiers ist mehrdimensional.

- oder -

types und modifiers weisen nicht die gleiche Länge auf.

Beispiele

Im folgenden Beispiel wird der Typ von MyClassabgerufen, das ConstructorInfo -Objekt abgerufen und die Konstruktorsignatur angezeigt.

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

Hinweise

Wenn keine genaue Übereinstimmung vorhanden ist, wird versucht, binder die im types Array angegebenen Parametertypen zu koerieren, um eine Übereinstimmung auszuwählen. Wenn die binder keine Übereinstimmung auswählen kann, null wird zurückgegeben.

Die folgenden BindingFlags Filterflags können verwendet werden, um zu definieren, welche Konstruktoren in die Suche einbezogen werden sollen:

• Sie müssen entweder BindingFlags.Instance oder BindingFlags.Static angeben, um eine Rückgabe zu erhalten.

• Geben Sie BindingFlags.Public an, um öffentliche Konstruktoren in die Suche einzuschließen.

• Geben Sie an BindingFlags.NonPublic , um nicht öffentliche Konstruktoren (d. h. private, interne und geschützte Konstruktoren) in die Suche einzuschließen.

Weitere Informationen finden Sie unter System.Reflection.BindingFlags.

Um den Klasseninitialisierer (statischer Konstruktor) mithilfe dieser Methodenüberladung abzurufen, müssen Sie (OrBindingFlags.NonPublicBindingFlags.Static in Visual Basic) angeben.BindingFlags.Static | BindingFlags.NonPublic Sie können den Klasseninitialisierer auch mithilfe der TypeInitializer -Eigenschaft abrufen.

Hinweis

Sie können beim Suchen nach Konstruktoren und Methoden keine Parameter weglassen. Parameter können beim Aufrufen nur weggelassen werden.

Wenn der aktuelle einen konstruierten generischen Type Typ darstellt, gibt diese Methode den ConstructorInfo mit den Typparametern zurück, die durch die entsprechenden Typargumente ersetzt werden. Wenn der aktuelle einen Typparameter in der Definition eines generischen Typs oder einer generischen Type Methode darstellt, gibt diese Methode immer zurück null.

Weitere Informationen

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

GetConstructor(BindingFlags, Type[])

Quelle:

Type.cs

Sucht unter Verwendung der angegebenen Bindungseinschränkungen nach einem Konstruktor, dessen Parameter den angegebenen Argumenttypen entsprechen.

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

Parameter

bindingAttr

BindingFlags

Eine bitweise Kombination der Enumerationswerte, die angeben, wie die Suche durchgeführt wird. Oder: Standardmäßig wird zurückgegeben null.

types

Type[]

Ein Array von Type-Objekten, die die Anzahl, Die Reihenfolge und den Typ der Parameter für den abzurufenden Konstruktor darstellen. oder: Ein leeres Array des Typs Type (d. h. Type[] types = Array.Empty{Type}()), um einen Konstruktor abzurufen, der keine Parameter akzeptiert. oder: EmptyTypes.

Gibt zurück

ConstructorInfo

Ein ConstructorInfo-Objekt, das den Konstruktor darstellt, der den angegebenen Anforderungen entspricht, oder null, wenn kein entsprechender Konstruktor gefunden wurde.

GetConstructor(Type[])

Quelle:

Type.cs

Sucht einen öffentlichen Instanzkonstruktor, dessen Parameter den Typen im angegebenen Array entsprechen.

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

Parameter

types

Type[]

Ein Array von Type-Objekten, das die Anzahl, die Reihenfolge und den Typ der Parameter des abzurufenden Konstruktors darstellt.

- oder -

Ein leeres Array von Type-Objekten zum Abrufen eines Konstruktors ohne Parameter. Das static-Feld EmptyTypes stellt ein entsprechendes leeres Array bereit.

Gibt zurück

ConstructorInfo

Ein Objekt, das den öffentlichen Instanzkonstruktor darstellt, dessen Parameter den Typen im Parametertyparray entsprechen, sofern gefunden, andernfalls null.

Ausnahmen

ArgumentNullException

types ist null.

- oder -

Eines der Elemente in types ist null.

ArgumentException

types ist mehrdimensional.

Beispiele

Im folgenden Beispiel wird der Typ von MyClassabgerufen, das ConstructorInfo -Objekt abgerufen und die Konstruktorsignatur angezeigt.

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

Hinweise

Diese Methodenüberladung sucht nach öffentlichen instance Konstruktoren und kann nicht zum Abrufen eines Klasseninitialisierers (statischer Konstruktor) verwendet werden. Verwenden Sie zum Abrufen eines Klasseninitialisierers eine Überladung, die akzeptiert BindingFlagsund (OrBindingFlags.NonPublicBindingFlags.Static in Visual Basic) angibt.BindingFlags.Static | BindingFlags.NonPublic Sie können den Klasseninitialisierer auch mithilfe der TypeInitializer -Eigenschaft abrufen.

Wenn der angeforderte Konstruktor nicht öffentlich ist, gibt diese Methode zurück null.

Hinweis

Sie können beim Suchen nach Konstruktoren und Methoden keine Parameter weglassen. Parameter können beim Aufrufen nur weggelassen werden.

Wenn der aktuelle einen konstruierten generischen Type Typ darstellt, gibt diese Methode den ConstructorInfo mit den Typparametern zurück, die durch die entsprechenden Typargumente ersetzt werden. Wenn der aktuelle einen Typparameter in der Definition eines generischen Typs oder einer generischen Type Methode darstellt, gibt diese Methode immer zurück null.

Weitere Informationen

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