(0) exportieren Drucken
Alle erweitern

Type.GetConstructors-Methode (BindingFlags)

Aktualisiert: November 2007

Sucht beim Überschreiben in einer abgeleiteten Klasse unter Verwendung der angegebenen BindingFlags die für den aktuellen Type definierten Konstruktoren.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

[ComVisibleAttribute(true)]
public abstract ConstructorInfo[] GetConstructors(
	BindingFlags bindingAttr
)
/** @attribute ComVisibleAttribute(true) */
public abstract ConstructorInfo[] GetConstructors(
	BindingFlags bindingAttr
)
public abstract function GetConstructors(
	bindingAttr : BindingFlags
) : ConstructorInfo[]

Parameter

bindingAttr
Typ: System.Reflection.BindingFlags
Eine Bitmaske aus einem oder mehreren BindingFlags, die angeben, wie die Suche durchgeführt wird.
– oder –
0 (null), damit null zurückgegeben wird.

Rückgabewert

Typ: System.Reflection.ConstructorInfo[]
Ein Array von ConstructorInfo-Objekten, die sämtliche für den aktuellen Type definierten Konstruktoren, einschließlich eines ggf. definierten Typinitialisierers, darstellen, die den angegebenen Bindungseinschränkungen entsprechen. Gibt ein leeres Array vom Typ ConstructorInfo zurück, wenn für den aktuellen Type keine Konstruktoren definiert sind, keiner der definierten Konstruktoren den Bindungseinschränkungen entspricht oder der aktuelle Type einen Typparameter einer generischen Typ- oder Methodendefinition darstellt.

Implementiert

_Type.GetConstructors(BindingFlags)

Die GetConstructors-Methode gibt Konstruktoren nicht in einer bestimmten Reihenfolge zurück, z. B. in der Reihenfolge der Deklaration usw. Der Code darf daher nicht von der Reihenfolge der zurückgegebenen Konstruktoren abhängen, da diese variieren kann.

Mit bindingAttr kann angegeben werden, ob nur öffentliche oder sowohl öffentliche als auch nicht öffentliche Konstruktoren zurückgegeben werden sollen.

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

Über die folgenden BindingFlags-Filterflags kann festgelegt werden, welche Konstruktoren in die Suche einbezogen werden:

  • Es wird nur dann ein Ergebnis zurückgegeben, wenn entweder BindingFlags.Instance oder BindingFlags.Static angegeben wird.

  • Geben Sie BindingFlags.Public an, um öffentliche Konstruktoren in die Suche einzubeziehen.

  • Geben Sie BindingFlags.NonPublic an, um nicht öffentliche Konstruktoren, d. h. private und geschützte Konstruktoren, in die Suche einzubeziehen.

Weitere Informationen finden Sie unter System.Reflection.BindingFlags.

Diese Methode gibt null zurück, wenn der angeforderte Konstruktor nicht öffentlich ist und der Aufrufer keine ReflectionPermission zum Reflektieren nicht öffentlicher Objekte außerhalb der aktuellen Assembly besitzt.

Um den Klasseninitialisierer (.cctor) mit dieser Methodenüberladung abzurufen, müssen Sie Folgendes angeben: BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.Static Or BindingFlags.NonPublic in Visual Basic). Sie können den Klasseninitialisierer auch mit der TypeInitializer-Eigenschaft abrufen.

Wenn der aktuelle Type einen konstruierten generischen Typ darstellt, gibt diese Methode die ConstructorInfo-Objekte zurück, wobei die Typparameter durch die entsprechenden Typargumente ersetzt wurden. Wenn die C<T> -Klasse z. B. den C(T t1)-Konstruktor besitzt (Sub New(ByVal t1 As T) in Visual Basic) und Sie GetConstructors mit C<int> aufrufen, wird eine ConstructorInfo zurückgegeben, die C(int t1) in C# (Sub New(ByVal t1 As Integer) in Visual Basic) darstellt.

Wenn der aktuelle Type einen generischen Typparameter darstellt, gibt die GetConstructors-Methode ein leeres Array zurück.

In diesem Beispiel wird die Ausgabe der GetConstructors()-Überladung für eine Klasse veranschaulicht, die zwei Instanzkonstruktoren und einen statischen Konstruktor besitzt.

using System;
using System.Reflection;

public class t {
    public t() {}
    static t() {}
    public t(int i) {}

    public static void Main() {
        ConstructorInfo[] p = typeof(t).GetConstructors();
        Console.WriteLine(p.Length);

        for (int i=0;i<p.Length;i++) {
            Console.WriteLine(p[i].IsStatic);
        }
    }
}


import System.*;
import System.Reflection.*;

public class T
{
    public T()
    {
    } //T

    static 
    {
    } //T

    public T(int i)
    {
    } //T

    public static void main(String[] args)
    {
        ConstructorInfo p[] = T.class.ToType().GetConstructors();
        Console.WriteLine(p.length);
        for (int i=0;i < p.length;i++) {
            Console.WriteLine(p[i].get_IsStatic());
        } 
    } //main
} //T


import System;
import System.Reflection;

public class t {
    public function t() {}
    static t {}
    public function t(i : int) {}

    public static function Main(): void  {
        var p : ConstructorInfo[] = t.GetConstructors();
        Console.WriteLine(p.Length);

        for (var i : int =0;i<p.Length;i++) {
            Console.WriteLine(p[i].IsStatic);
        }
    }
}
t.Main();


Die Ausgabe dieses Codes lautet wie folgt:

2

False

False

Da die GetConstructors-Überladung nur Public und Instance verwendet, wird der statische Konstruktor weder im for-Ausdruck gezählt noch von IsStatic ausgewertet.

Um statische Konstruktoren zu finden, verwenden Sie die GetConstructors-Überladung, und übergeben Sie ihr die Kombination (logisches OR) von BindingFlags.Public, BindingFlags.Static, BindingFlags.NonPublic und BindingFlags.Instance, wie im folgenden Beispiel veranschaulicht:

using System;
using System.Reflection;

public class t {
    public t() {}
    static t() {}
    public t(int i) {}

    public static void Main() {
        ConstructorInfo[] p = typeof(t).GetConstructors(
           BindingFlags.Public | BindingFlags.Static |
           BindingFlags.NonPublic | BindingFlags.Instance);
        Console.WriteLine(p.Length);

        for (int i=0;i<p.Length;i++) {
            Console.WriteLine(p[i].IsStatic);
        }
    }
}


import System.*;
import System.Reflection.*;

public class T
{
    public T() 
    {
    } //T

    static
    {
    } //T

    public T(int i)
    {
    } //T

    public static void main(String[] args)
    {
        ConstructorInfo p[] = T.class.ToType().GetConstructors(
            (BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic
            | BindingFlags.Instance)); 
        Console.WriteLine(p.length);
        for (int i=0;i< p.length;i++) {
            Console.WriteLine(p[i].get_IsStatic());
        } 
    } //main
} //T


import System;
import System.Reflection;

public class t {
    public function t() {}
    static t {}
    public function t(i : int) {}

    public static function Main() : void  {
        var p : ConstructorInfo[] = t.GetConstructors(
           BindingFlags.Public | BindingFlags.Static |
           BindingFlags.NonPublic | BindingFlags.Instance);
        Console.WriteLine(p.Length);

        for (var i:int=0;i<p.Length;i++) {
            Console.WriteLine(p[i].IsStatic);
        }
    }
}
t.Main();


Die Ausgabe lautet nun wie folgt:

3

False

True

False

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile für Smartphone, Windows Mobile für Pocket PC, Xbox 360

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 3.5, 2.0, 1.0

XNA Framework

Unterstützt in: 2.0, 1.0

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft