Type.GetFields Método

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

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

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

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

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

Public Function GetFields () As FieldInfo()

Devoluções

Um array de FieldInfo objetos que representa todos os campos públicos definidos para o atual Type.

-ou-

Um array vazio de tipo FieldInfo, se não forem definidos campos públicos para o atual Type.

Implementações

Exemplos

O exemplo seguinte mostra a utilização do GetFields() método.

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

Observações

Em versões .NET 6 e anteriores, o método GetFields não devolve campos numa ordem específica, como ordem alfabética ou de declaração. O seu código não deve depender da ordem em que os campos são devolvidos, porque essa ordem varia. No entanto, a partir do .NET 7, a ordenação é determinística com base na ordenação dos metadados na assembleia.

A tabela a seguir mostra quais membros de uma classe base são retornados pelos Get métodos ao refletir sobre um tipo.

Tipo de Membro	Estático	Não-estático
Construtor	No	No
Campo	No	Yes. Um campo é sempre ocultado com base no nome e assinatura.
Event	Não aplicável	A regra comum do sistema de tipos é que a herança é a mesma dos métodos que implementam a propriedade. A reflexão trata propriedades como esconder pelo nome e assinatura. Veja a nota 2 abaixo.
Método	No	Yes. Um método (virtual e não virtual) pode ser ocultado por nome ou ocultado por nome e assinatura.
Tipo aninhado	No	No
Property	Não aplicável	A regra comum do sistema de tipos é que a herança é a mesma dos métodos que implementam a propriedade. A reflexão trata propriedades como esconder pelo nome e assinatura. Veja a nota 2 abaixo.

1. Ocultar por nome e assinatura considera todas as partes da assinatura, incluindo modificadores personalizados, tipos de retorno, tipos de parâmetros, sentinelas e convenções de chamada não gerenciadas. Esta é uma comparação binária.

2. Para reflexão, as propriedades e os eventos são ocultados por nome e assinatura. Se você tiver uma propriedade com um acessador get e um set na classe base, mas a classe derivada tiver apenas um acessor get, a propriedade de classe derivada ocultará a propriedade de classe base e você não poderá acessar o setter na classe base.

3. Os atributos personalizados não fazem parte do sistema de tipo comum.

Se a corrente Type representa um tipo genérico construído, este método devolve os FieldInfo objetos com os parâmetros de tipo substituídos pelos argumentos de tipo apropriados.

Se a corrente Type representa um parâmetro de tipo na definição de um tipo genérico ou método genérico, este método pesquisa os campos públicos da restrição de classe.

Ver também

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

Parâmetros

Devoluções

Um array de FieldInfo objetos que representa todos os campos definidos para a corrente Type que correspondem às restrições de ligação especificadas.

-ou-

Um array vazio do tipo FieldInfo, se não forem definidos campos para o atual Type, ou se nenhum dos campos definidos corresponder às restrições de ligação.

Implementações

Exemplos

O exemplo seguinte mostra a utilização do GetFields(BindingFlags) método.

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

Observações

Para que a GetFields(BindingFlags) sobrecarga recupere com sucesso informação de propriedades, o bindingAttr argumento deve incluir pelo menos um de BindingFlags.Instance e BindingFlags.Static, juntamente com pelo menos um de BindingFlags.NonPublic e BindingFlags.Public.

As seguintes BindingFlags bandeiras de filtro podem ser usadas para definir quais os campos a incluir na pesquisa:

• Especifique BindingFlags.Instance incluir métodos de instância.

• Especifique BindingFlags.Static a inclusão de métodos estáticos.

• Especifique BindingFlags.Public a inclusão de campos públicos na pesquisa.

• Especifique BindingFlags.NonPublic a inclusão de campos não públicos (ou seja, privados, internos e protegidos) na pesquisa. Apenas os campos protegidos e internos nas classes base são devolvidos; Campos privados nas classes base não são devolvidos.

• Especifique BindingFlags.FlattenHierarchy para incluir public e protected membros estáticos na hierarquia; private membros estáticos em classes herdadas não são incluídos.

• Especifique BindingFlags.Default sozinho para devolver um array vazio PropertyInfo .

Os seguintes BindingFlags sinalizadores modificadores podem ser usados para alterar o funcionamento da pesquisa:

• BindingFlags.DeclaredOnly para pesquisar apenas os campos declarados no Type, não os campos que foram simplesmente herdados.

Consulte System.Reflection.BindingFlags para obter mais informações.

Em versões .NET 6 e anteriores, o método GetFields não devolve campos numa ordem específica, como ordem alfabética ou de declaração. O seu código não deve depender da ordem em que os campos são devolvidos, porque essa ordem varia. No entanto, a partir do .NET 7, a ordenação é determinística com base na ordenação dos metadados na assembleia.

Se a corrente Type representa um tipo genérico construído, este método devolve os FieldInfo objetos com os parâmetros de tipo substituídos pelos argumentos de tipo apropriados.

Se a corrente Type representa um parâmetro de tipo na definição de um tipo genérico ou método genérico, este método pesquisa os campos públicos da restrição de classe.

Ver também

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