Type.GetFields Méthode

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

Source:

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

Retours

Tableau d’objets FieldInfo représentant tous les champs publics définis pour le actif Type.

- ou -

Tableau vide de type FieldInfo, si aucun champ public n’est défini pour l’actuel Type.

Implémente

Attributs

DynamicallyAccessedMembersAttribute

Exemples

L’exemple suivant montre une utilisation de la GetFields() méthode.

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

Remarques

Dans .NET 6 et versions antérieures, la méthode GetFields ne retourne pas de champs dans un ordre particulier, tel que l’ordre alphabétique ou de déclaration. Votre code ne doit pas dépendre de l’ordre dans lequel les champs sont retournés, car cet ordre varie. Toutefois, à partir de .NET 7, l’ordre est déterministe en fonction de l’ordre des métadonnées dans l’assembly.

Le tableau suivant montre quels membres d'une classe de base sont retournés par les Get méthodes lors de la réflexion sur un type.

Type de membre	Static	Non statique
Constructor	Non	Non
Champ	Non	Yes. Un champ est toujours masqué par nom et signature.
Event	Sans objet	La règle du système de type courant est que l'héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.
Méthode	Non	Yes. Une méthode (virtuelle et non virtuelle) peut être masquée par nom ou par nom et signature.
Type imbriqué	Non	Non
Propriété	Sans objet	La règle du système de type courant est que l'héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.

1. Hide-by-name-and-signature prend en compte toutes les parties de la signature, notamment les modificateurs personnalisés, les types de retour, les types de paramètres, les sentinelles et les conventions d’appel non managées. Il s’agit d’une comparaison binaire.

2. Pour la réflexion, les propriétés et les événements sont masqués par nom et signature. Si vous avez une propriété avec un accesseur get et un accesseur set dans la classe de base, mais que la classe dérivée n’a qu’un accesseur get, la propriété de classe dérivée masque la propriété de classe de base et vous ne pourrez pas accéder au setter sur la classe de base.

3. Les attributs personnalisés ne font pas partie du système de type commun.

Si le courant Type représente un type générique construit, cette méthode retourne les objets avec les FieldInfo paramètres de type remplacés par les arguments de type appropriés.

Si le paramètre actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode recherche les champs publics de la contrainte de classe.

Voir aussi

• FieldInfo
• GetField(String, BindingFlags)

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

Source:

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

Paramètres

Retours

Tableau d’objets représentant tous les champs définis pour le courant FieldInfo qui correspondent aux contraintes de Type liaison spécifiées.

- ou -

Tableau vide de type FieldInfo, si aucun champ n’est défini pour le champ actif Typeou si aucun des champs définis ne correspond aux contraintes de liaison.

Implémente

Attributs

DynamicallyAccessedMembersAttribute

Exemples

L’exemple suivant montre une utilisation de la GetFields(BindingFlags) méthode.

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

Remarques

Pour que la GetFields(BindingFlags) surcharge récupère correctement les informations de propriété, l’argument bindingAttr doit inclure au moins un des BindingFlags.InstanceBindingFlags.Static éléments et , ainsi qu’au moins un des BindingFlags.NonPublic éléments et BindingFlags.Public.

Les indicateurs de filtre suivants BindingFlags peuvent être utilisés pour définir les champs à inclure dans la recherche :

• Spécifiez BindingFlags.Instance d’inclure des méthodes d’instance.

• Spécifiez BindingFlags.Static d’inclure des méthodes statiques.

• Spécifiez BindingFlags.Public d’inclure des champs publics dans la recherche.

• Spécifiez BindingFlags.NonPublic d’inclure des champs non publics (c’est-à-dire des champs privés, internes et protégés) dans la recherche. Seuls les champs protégés et internes sur les classes de base sont retournés ; les champs privés sur les classes de base ne sont pas retournés.

• Spécifiez BindingFlags.FlattenHierarchy pour inclure public et protected les membres statiques de la hiérarchie ; les membres statiques des classes héritées private ne sont pas inclus.

• Spécifiez BindingFlags.Default uniquement pour retourner un tableau vide PropertyInfo .

Les indicateurs de modification suivants BindingFlags peuvent être utilisés pour modifier le fonctionnement de la recherche :

• BindingFlags.DeclaredOnly pour rechercher uniquement les champs déclarés sur le Type, et non les champs qui ont été simplement hérités.

Pour plus d’informations, consultez System.Reflection.BindingFlags.

Dans .NET 6 et versions antérieures, la méthode GetFields ne retourne pas de champs dans un ordre particulier, tel que l’ordre alphabétique ou de déclaration. Votre code ne doit pas dépendre de l’ordre dans lequel les champs sont retournés, car cet ordre varie. Toutefois, à partir de .NET 7, l’ordre est déterministe en fonction de l’ordre des métadonnées dans l’assembly.

Si le courant Type représente un type générique construit, cette méthode retourne les objets avec les FieldInfo paramètres de type remplacés par les arguments de type appropriés.

Si le paramètre actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode recherche les champs publics de la contrainte de classe.

Voir aussi

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