Esporta (0) Stampa
Espandi tutto

Metodo Type.GetConstructors (BindingFlags)

Quando è sottoposto a override in una classe derivata, cerca i costruttori definiti per il Type corrente, utilizzando i BindingFlags specificati.

Spazio dei nomi: System
Assembly: mscorlib (in mscorlib.dll)

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

Parametri

bindingAttr

Maschera di bit costituita da uno o più BindingFlags che consentono di specificare le modalità di esecuzione della ricerca.

-oppure-

Zero, per restituire riferimento null (Nothing in Visual Basic).

Valore restituito

Una matrice di oggetti ConstructorInfo che rappresentano tutti i costruttori definiti per il Type corrente corrispondente ai vincoli di associazione specificati, compreso l'inizializzatore di tipo, se definito. Restituisce una matrice vuota di tipo ConstructorInfo se per l'oggetto Type corrente non sono definiti costruttori, se nessuno dei costruttori definiti corrisponde ai vincoli di associazione o se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico.

Il metodo GetConstructors non restituisce i costruttori in un ordine particolare, ad esempio l'ordine di dichiarazione. Il codice non deve dipendere dall'ordine in cui i costruttori vengono restituiti perché tale ordine varia.

bindingAttr può essere utilizzato per specificare se restituire soltanto costruttori di tipo pubblico oppure costruttori di tipo pubblico e non pubblico.

Se non esiste una corrispondenza esatta, il binder tenterà di assegnare forzatamente i tipi di parametro specificati nella matrice types in modo da selezionare una corrispondenza. Se il binder non è in grado di selezionare una corrispondenza, viene restituito riferimento null (Nothing in Visual Basic).

È possibile utilizzare i seguenti flag di filtro BindingFlags per definire i costruttori da includere nella ricerca:

  • Per ottenere un risultato è necessario specificare BindingFlags.Instance o BindingFlags.Static.

  • Specificare BindingFlags.Public per includere nella ricerca costruttori di tipo pubblico.

  • Specificare BindingFlags.NonPublic per includere nella ricerca costruttori di tipo non pubblico, ovvero costruttori privati e protetti.

Per ulteriori informazioni, vedere System.Reflection.BindingFlags.

Se il costruttore richiesto non è pubblico e il chiamante non dispone dell'oggetto ReflectionPermission necessario per eseguire la reflection degli oggetti non pubblici al di fuori dell'assembly corrente, il metodo restituisce riferimento null (Nothing in Visual Basic).

Per ottenere l'inizializzatore di classi (con estensione cctor) tramite l'overload di questo metodo, è necessario specificare BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.StaticOrBindingFlags.NonPublic in Visual Basic). Per ottenere l'inizializzatore di classi, è inoltre possibile utilizzare la proprietà TypeInitializer.

Se l'oggetto Type corrente rappresenta un tipo generico costruito, questo metodo restituisce gli oggetti ConstructorInfo con i parametri di tipo sostituiti dagli argomenti di tipo appropriati. Se ad esempio la classe C<T> dispone di un costruttore C(T t1) (Sub New(ByVal t1 As T) in Visual Basic), la chiamata del metodo GetConstructors su C<int> restituisce una classe ConstructorInfo che rappresenta C(int t1) in C# (Sub New(ByVal t1 As Integer) in Visual Basic).

Se l'oggetto Type rappresenta un parametro di tipo generico, il metodo GetConstructors restituisce una matrice vuota.

In questo esempio viene illustrato l'output dell'overload del metodo GetConstructors da una classe che dispone di due costruttori di istanza e un costruttore statico.

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

L'output del codice è:

2

False

False

Poiché l'overload del metodo GetConstructors utilizza soltanto Public e Instance, il costruttore statico non viene conteggiato dall'espressione for né valutato da IsStatic.

Per individuare costruttori statici, utilizzare l'overload del metodo GetConstructors e passare la combinazione (OR logico) di BindingFlags.Public, BindingFlags.Static, BindingFlags.NonPublic, BindingFlags.Instance, come illustrato nell'esempio di codice riportato di seguito.

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

Ora l'output è:

3

False

True

False

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile per Pocket PC, Windows Mobile per Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 è supportato in Windows Vista, Microsoft Windows XP SP2 e Windows Server 2003 SP1.

.NET Framework

Supportato in:

.NET Compact Framework

Supportato in:

XNA Framework

Supportato in:

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2014 Microsoft