Type.GetFields Metodo

Origine:

Type.cs

Origine:

Type.cs

Origine:

Type.cs

Origine:

Type.cs

Origine:

Type.cs

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

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)]
public System.Reflection.FieldInfo[] GetFields();

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

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)>]
member this.GetFields : unit -> System.Reflection.FieldInfo[]

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

Valori restituiti

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

oppure

Matrice vuota di tipo FieldInfo, se non sono definiti campi pubblici per l'oggetto corrente Type.

Implementazioni

Attributi

DynamicallyAccessedMembersAttribute

Esempio

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

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

open System.ComponentModel.Design

try
    // Get the type handle of a specified class.
    let myType = typeof<ViewTechnology>

    // Get the fields of the specified class.
    let myFields = myType.GetFields()

    printfn $"\nDisplaying fields that have SpecialName attributes:\n"
    for field in myFields do
        // Determine whether or not each field is a special name.
        if field.IsSpecialName then
            printfn $"The field {field.Name} has a SpecialName attribute."
with e ->
    printfn $"Exception : {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

In .NET 6 e versioni precedenti, il metodo GetFields non restituisce campi in un ordine specifico, ad esempio ordine alfabetico o di dichiarazione. Il codice non deve dipendere dall'ordine in cui vengono restituiti i campi, perché tale ordine varia. Tuttavia, a partire da .NET 7, l'ordinamento è deterministico in base all'ordinamento dei metadati nell'assembly.

Nella tabella seguente vengono illustrati i membri della classe base restituiti dai Get metodi quando si analizza un tipo.

Tipo di membro	Static	Non statico
Costruttore	No	No
Campo	No	Yes. Un campo è sempre nascosto per nome e firma.
Event	Non applicabile	La regola di sistema dei tipi comune è che l'ereditarietà è uguale a quella dei metodi che implementano la proprietà . La reflection considera le proprietà come hide-by-name-and-signature. Vedere la nota 2 di seguito.
metodo	No	Yes. Un metodo (virtuale e non virtuale) può essere nascosto per nome o nascosto per nome e firma.
Tipo annidato	No	No
Proprietà	Non applicabile	La regola di sistema dei tipi comune è che l'ereditarietà è uguale a quella dei metodi che implementano la proprietà . La reflection considera le proprietà come hide-by-name-and-signature. Vedere la nota 2 di seguito.

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. In riflessione, le proprietà e gli eventi sono hide-by-name-and-signature. Se si dispone di una proprietà con una funzione di accesso get e set nella classe 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 base.

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

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

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

Vedi anche

• FieldInfo
• GetField(String, BindingFlags)

Origine:

Type.cs

Origine:

Type.cs

Origine:

Type.cs

Origine:

Type.cs

Origine:

Type.cs

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)]
public abstract System.Reflection.FieldInfo[] GetFields(System.Reflection.BindingFlags bindingAttr);

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

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)>]
abstract member GetFields : System.Reflection.BindingFlags -> System.Reflection.FieldInfo[]

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

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

Parametri

Valori restituiti

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

oppure

Matrice vuota di tipo FieldInfo, se non sono definiti campi per l'oggetto corrente Typeo se nessuno dei campi definiti corrisponde ai vincoli di associazione.

Implementazioni

Attributi

DynamicallyAccessedMembersAttribute

Esempio

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

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

open System
open System.Reflection

type AttributesSample() =
    member _.Mymethod(int1m: int, str2m: string outref, str3m: string byref) =
        str2m <- "in Mymethod"

let printAttributes (attribType: Type) iAttribValue =
    if not attribType.IsEnum then
        printfn "This type is not an enum."
    else
        let fields = attribType.GetFields(BindingFlags.Public ||| BindingFlags.Static)
        for f in fields do
            let fieldvalue = f.GetValue null :?> int
            if fieldvalue &&& iAttribValue = fieldvalue then
                printfn $"{f.Name}"

printfn "Reflection.MethodBase.Attributes Sample"

// Get the type.
let MyType = Type.GetType "AttributesSample"

// Get the method Mymethod on the type.
let Mymethodbase = MyType.GetMethod "Mymethod"

// Display the method name.
printfn $"Mymethodbase = {Mymethodbase}"

// Get the MethodAttribute enumerated value.
let Myattributes = Mymethodbase.Attributes

// Display the flags that are set.
printAttributes typeof<MethodAttributes> (int Myattributes)

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

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

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

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

• Specificare BindingFlags.Static per includere metodi statici.

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

• Specificare BindingFlags.NonPublic di includere campi non pubblici (ovvero campi privati, interni e protetti) nella ricerca. Vengono restituiti solo campi protetti e interni sulle classi di base; i campi privati sulle classi di base non vengono restituiti.

• Specificare BindingFlags.FlattenHierarchy di includere public e protected membri statici nella gerarchia. private I membri statici nelle classi ereditate non sono inclusi.

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

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

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

Per altre informazioni, vedere System.Reflection.BindingFlags.

In .NET 6 e versioni precedenti, il metodo GetFields non restituisce campi in un ordine specifico, ad esempio ordine alfabetico o di dichiarazione. Il codice non deve dipendere dall'ordine in cui vengono restituiti i campi, perché tale ordine varia. Tuttavia, a partire da .NET 7, l'ordinamento è deterministico in base all'ordinamento dei metadati nell'assembly.

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

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

Vedi anche

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