Type.GetFields Metodo

public:
 cli::array <System::Reflection::FieldInfo ^> ^ GetFields();

public:
 virtual cli::array <System::Reflection::FieldInfo ^> ^ GetFields();

public System.Reflection.FieldInfo[] GetFields ();

member this.GetFields : unit -> System.Reflection.FieldInfo[]

abstract member GetFields : unit -> System.Reflection.FieldInfo[]
override this.GetFields : unit -> System.Reflection.FieldInfo[]

Public Function GetFields () As FieldInfo()

Restituisce

FieldInfo[]

Matrice di oggetti FieldInfo che rappresentano tutti i campi pubblici definiti per l'oggetto Type corrente.

-oppure- Matrice vuota di tipo FieldInfo, se non è definito alcun campo pubblico per l'oggetto Type corrente.

Implementazioni

Esempio

Nell'esempio seguente viene illustrato l'utilizzo del GetFields() metodo .

#using <system.dll>

using namespace System;
using namespace System::Reflection;
using namespace System::ComponentModel::Design;

int main()
{
   try
   {
      // Get the type handle of a specified class.
      Type^ myType = ViewTechnology::typeid;

      // Get the fields of the specified class.
      array<FieldInfo^>^myField = myType->GetFields();
      Console::WriteLine( "\nDisplaying fields that have SpecialName attributes:\n" );
      for ( int i = 0; i < myField->Length; i++ )
      {
         // Determine whether or not each field is a special name.
         if ( myField[ i ]->IsSpecialName )
         {
            Console::WriteLine( "The field {0} has a SpecialName attribute.", myField[ i ]->Name );
         }
      }
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception : {0} ", e->Message );
   }
}

using System;
using System.Reflection;
using System.ComponentModel.Design;

class FieldInfo_IsSpecialName
{
    public static void Main()
    {
        try
        {
            // Get the type handle of a specified class.
            Type myType = typeof(ViewTechnology);

            // Get the fields of the specified class.
            FieldInfo[] myField = myType.GetFields();

            Console.WriteLine("\nDisplaying fields that have SpecialName attributes:\n");
            for(int i = 0; i < myField.Length; i++)
            {
                // Determine whether or not each field is a special name.
                if(myField[i].IsSpecialName)
                {
                    Console.WriteLine("The field {0} has a SpecialName attribute.",
                        myField[i].Name);
                }
            }
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception : {0} " , e.Message);
        }
    }
}

Imports System.Reflection
Imports System.ComponentModel.Design

Class FieldInfo_IsSpecialName

    Public Shared Sub Main()
        Try
            ' Get the type handle of a specified class.
            Dim myType As Type = GetType(ViewTechnology)

            ' Get the fields of a specified class.
            Dim myField As FieldInfo() = myType.GetFields()

            Console.WriteLine(ControlChars.Cr + "Displaying fields that have SpecialName attributes:" + ControlChars.Cr)
            Dim i As Integer
            For i = 0 To myField.Length - 1
                ' Determine whether or not each field is a special name.
                If myField(i).IsSpecialName Then
                    Console.WriteLine("The field {0} has a SpecialName attribute.", myField(i).Name)
                End If
            Next i
        Catch e As Exception
            Console.WriteLine("Exception : {0} ", e.Message.ToString())
        End Try
    End Sub
End Class

Commenti

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

Nella tabella seguente vengono illustrati i membri di una classe di base restituiti dai Get metodi quando si esegue la reflecting su un tipo.

1. Hide-by-name-and-signature considera tutte le parti della firma, inclusi modificatori personalizzati, tipi restituiti, tipi di parametro, sentinel e convenzioni di chiamata non gestite. Si tratta di un confronto binario.

2. Per la reflection, le proprietà e gli eventi sono hide-by-name-and-signature. Se si dispone di una proprietà con una funzione di accesso get e una funzione di accesso set nella classe di base, ma la classe derivata ha solo una funzione di accesso get, la proprietà della classe derivata nasconde la proprietà della classe base e non sarà possibile accedere al setter nella classe di base.

3. Gli attributi personalizzati non fanno parte del sistema di tipi comune.

Se l'oggetto corrente rappresenta un tipo generico costruito, questo metodo restituisce gli oggetti con Type i parametri di tipo FieldInfo sostituiti dagli argomenti di tipo appropriati.

Se l'oggetto corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico, questo metodo cerca nei Type campi pubblici del vincolo di classe.

Vedi anche

• FieldInfo
• GetField(String, BindingFlags)

public:
 abstract cli::array <System::Reflection::FieldInfo ^> ^ GetFields(System::Reflection::BindingFlags bindingAttr);

public abstract System.Reflection.FieldInfo[] GetFields (System.Reflection.BindingFlags bindingAttr);

abstract member GetFields : System.Reflection.BindingFlags -> System.Reflection.FieldInfo[]

Public MustOverride Function GetFields (bindingAttr As BindingFlags) As FieldInfo()

Parametri

Restituisce

FieldInfo[]

Matrice di oggetti FieldInfo che rappresentano tutti i campi definiti per l'oggetto Type corrente corrispondente ai vincoli di binding specificati.

-oppure- Matrice vuota di tipo FieldInfo, se non è definito alcun campo per l'oggetto Type corrente oppure se nessuno dei campi definiti corrisponde ai vincoli di binding.

Implementazioni

Esempio

Nell'esempio seguente viene illustrato l'utilizzo del GetFields(BindingFlags) metodo .

using namespace System;
using namespace System::Reflection;
using namespace System::Runtime::InteropServices;
public ref class AttributesSample
{
public:
   void Mymethod( int int1m, [Out]interior_ptr<String^> str2m, interior_ptr<String^> str3m )
   {
       *str2m = "in Mymethod";
   }
};

void PrintAttributes( Type^ attribType, int iAttribValue )
{
   if (  !attribType->IsEnum )
   {
      Console::WriteLine( "This type is not an enum." );
      return;
   }

   array<FieldInfo^>^fields = attribType->GetFields( static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Static) );
   for ( int i = 0; i < fields->Length; i++ )
   {
      int fieldvalue = safe_cast<Int32>(fields[ i ]->GetValue( nullptr ));
      if ( (fieldvalue & iAttribValue) == fieldvalue )
      {
         Console::WriteLine( fields[ i ]->Name );
      }
   }
}

int main()
{
   Console::WriteLine( "Reflection.MethodBase.Attributes Sample" );

   // Get the type.
   Type^ MyType = Type::GetType( "AttributesSample" );

   // Get the method Mymethod on the type.
   MethodBase^ Mymethodbase = MyType->GetMethod( "Mymethod" );

   // Display the method name.
   Console::WriteLine( "Mymethodbase = {0}", Mymethodbase );

   // Get the MethodAttribute enumerated value.
   MethodAttributes Myattributes = Mymethodbase->Attributes;

   // Display the flags that are set.
   PrintAttributes( System::Reflection::MethodAttributes::typeid, (int)Myattributes );
   return 0;
}

using System;
using System.Reflection;

class AttributesSample
{
    public void Mymethod (int int1m, out string str2m, ref string str3m)
    {
        str2m = "in Mymethod";
    }

    public static int Main(string[] args)
    {
        Console.WriteLine ("Reflection.MethodBase.Attributes Sample");

        // Get the type.
        Type MyType = Type.GetType("AttributesSample");

        // Get the method Mymethod on the type.
        MethodBase Mymethodbase = MyType.GetMethod("Mymethod");

        // Display the method name.
        Console.WriteLine("Mymethodbase = " + Mymethodbase);

        // Get the MethodAttribute enumerated value.
        MethodAttributes Myattributes = Mymethodbase.Attributes;

        // Display the flags that are set.
        PrintAttributes(typeof(System.Reflection.MethodAttributes), (int) Myattributes);
        return 0;
    }

    public static void PrintAttributes(Type attribType, int iAttribValue)
    {
        if (!attribType.IsEnum)
        {
            Console.WriteLine("This type is not an enum.");
            return;
        }

        FieldInfo[] fields = attribType.GetFields(BindingFlags.Public | BindingFlags.Static);
        for (int i = 0; i < fields.Length; i++)
        {
            int fieldvalue = (int)fields[i].GetValue(null);
            if ((fieldvalue & iAttribValue) == fieldvalue)
            {
                Console.WriteLine(fields[i].Name);
            }
        }
    }
}

Imports System.Reflection

Class AttributesSample

    Public Sub Mymethod(ByVal int1m As Integer, ByRef str2m As String, ByRef str3m As String)
        str2m = "in Mymethod"
    End Sub

    Public Shared Function Main(ByVal args() As String) As Integer
        Console.WriteLine("Reflection.MethodBase.Attributes Sample")

        ' Get the type.
        Dim MyType As Type = Type.GetType("AttributesSample")

        ' Get the method Mymethod on the type.
        Dim Mymethodbase As MethodBase = MyType.GetMethod("Mymethod")

        ' Display the method name.
        Console.WriteLine("Mymethodbase = {0}.", Mymethodbase)

        ' Get the MethodAttribute enumerated value.
        Dim Myattributes As MethodAttributes = Mymethodbase.Attributes

        ' Display the flags that are set.
        PrintAttributes(GetType(System.Reflection.MethodAttributes), CInt(Myattributes))
        Return 0
    End Function 'Main

    Public Shared Sub PrintAttributes(ByVal attribType As Type, ByVal iAttribValue As Integer)
        If Not attribType.IsEnum Then
            Console.WriteLine("This type is not an enum.")
            Return
        End If
        Dim fields As FieldInfo() = attribType.GetFields((BindingFlags.Public Or BindingFlags.Static))
        Dim i As Integer
        For i = 0 To fields.Length - 1
            Dim fieldvalue As Integer = CType(fields(i).GetValue(Nothing), Int32)
            If (fieldvalue And iAttribValue) = fieldvalue Then
                Console.WriteLine(fields(i).Name)
            End If
        Next i
    End Sub
End Class

Commenti

Perché l'overload recupeni correttamente le informazioni sulle GetFields(BindingFlags) proprietà, l'argomento deve includere almeno uno di e , insieme ad bindingAttr almeno uno di e BindingFlags.Instance BindingFlags.Static BindingFlags.NonPublic BindingFlags.Public .

I flag BindingFlags di filtro seguenti possono essere usati per definire i campi da includere nella ricerca:

• Specificare per BindingFlags.Instance includere i metodi di istanza.

• Specificare BindingFlags.Static per includere metodi statici.

• Specificare BindingFlags.Public per includere i campi pubblici nella ricerca.

• Specificare per includere nella ricerca i campi non pubblici, ovvero i campi privati, interni BindingFlags.NonPublic e protetti. Vengono restituiti solo i campi protetti e interni nelle classi di base. I campi privati nelle classi di base non vengono restituiti.

• Specificare BindingFlags.FlattenHierarchy per includere i membri public protected statici e verso l'alto nella gerarchia. I private membri statici nelle classi ereditate non sono inclusi.

• Specificare BindingFlags.Default da solo per restituire una matrice PropertyInfo vuota.

Per modificare BindingFlags il funzionamento della ricerca, è possibile usare i flag di modifica seguenti:

• BindingFlags.DeclaredOnly per cercare solo i campi dichiarati in Type , non i campi semplicemente ereditati.

Per altre informazioni, vedere System.Reflection.BindingFlags.

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

Se l'oggetto corrente rappresenta un tipo generico costruito, questo metodo restituisce gli oggetti con Type i parametri di tipo FieldInfo sostituiti dagli argomenti di tipo appropriati.

Se l'oggetto corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico, questo metodo cerca nei Type campi pubblici del vincolo di classe.

Vedi anche

• FieldInfo
• BindingFlags
• DefaultBinder
• GetField(String, BindingFlags)