Compartilhar via


Enum.GetValues Método

Definição

Sobrecargas

GetValues(Type)

Recupera uma matriz de valores de constantes em uma enumeração especificada.

GetValues<TEnum>()

Recupera uma matriz de valores de constantes em um tipo de enumeração especificado.

GetValues(Type)

Origem:
Enum.cs
Origem:
Enum.cs
Origem:
Enum.cs

Recupera uma matriz de valores de constantes em uma enumeração especificada.

public:
 static Array ^ GetValues(Type ^ enumType);
public static Array GetValues (Type enumType);
[System.Runtime.InteropServices.ComVisible(true)]
public static Array GetValues (Type enumType);
static member GetValues : Type -> Array
[<System.Runtime.InteropServices.ComVisible(true)>]
static member GetValues : Type -> Array
Public Shared Function GetValues (enumType As Type) As Array

Parâmetros

enumType
Type

Um tipo de enumeração.

Retornos

Uma matriz que contém os valores das constantes em enumType.

Atributos

Exceções

enumType é null.

enumType não é um Enum.

O método é invocado por reflexão em um contexto de somente reflexão,

- ou -

enumType é um tipo de um assembly carregado em um contexto de somente reflexão.

.NET 8 e versões posteriores: enumType é um tipo de enumeração com suporte booliano.

Exemplos

O exemplo a seguir ilustra o uso de GetValues.

using namespace System;
enum class Colors
{
   Red, Green, Blue, Yellow
};

enum class Styles
{
   Plaid = 0,
   Striped = 23,
   Tartan = 65,
   Corduroy = 78
};

int main()
{
   Console::WriteLine(  "The values of the Colors Enum are:" );
   Array^ a = Enum::GetValues( Colors::typeid );
   for ( Int32 i = 0; i < a->Length; i++ )
   {
      Object^ o = a->GetValue( i );
      Console::WriteLine(  "{0}", Enum::Format( Colors::typeid, o,  "D" ) );
   }
   Console::WriteLine();
   Console::WriteLine(  "The values of the Styles Enum are:" );
   Array^ b = Enum::GetValues( Styles::typeid );
   for ( Int32 i = 0; i < b->Length; i++ )
   {
      Object^ o = b->GetValue( i );
      Console::WriteLine(  "{0}", Enum::Format( Styles::typeid, o,  "D" ) );

   }
}
// The example produces the following output:
//       The values of the Colors Enum are:
//       0
//       1
//       2
//       3
//       
//       The values of the Styles Enum are:
//       0
//       23
//       65
//       78
using System;

public class GetValuesTest {
    enum Colors { Red, Green, Blue, Yellow };
    enum Styles { Plaid = 0, Striped = 23, Tartan = 65, Corduroy = 78 };

    public static void Main() {

        Console.WriteLine("The values of the Colors Enum are:");
        foreach(int i in Enum.GetValues(typeof(Colors)))
            Console.WriteLine(i);

        Console.WriteLine();

        Console.WriteLine("The values of the Styles Enum are:");
        foreach(int i in Enum.GetValues(typeof(Styles)))
            Console.WriteLine(i);
    }
}
// The example produces the following output:
//       The values of the Colors Enum are:
//       0
//       1
//       2
//       3
//
//       The values of the Styles Enum are:
//       0
//       23
//       65
//       78
open System

type Colors =
    | Red = 0
    | Green = 1
    | Blue = 2
    | Yellow = 3
    
type Styles =
    | Plaid = 0
    | Striped = 23
    | Tartan = 65
    | Corduroy = 78

printfn $"The values of the Colors Enum are:"
for i in Enum.GetValues typeof<Colors> do
    printfn $"{i}"

printfn "\nThe values of the Styles Enum are:"
for i in Enum.GetValues typeof<Styles> do
    printfn $"{i}"

// The example produces the following output:
//       The values of the Colors Enum are:
//       0
//       1
//       2
//       3
//
//       The values of the Styles Enum are:
//       0
//       23
//       65
//       78
Public Class GetValuesTest
   
    Enum Colors
        Red
        Green
        Blue
        Yellow
    End Enum 'Colors
    
    Enum Styles
        Plaid = 0
        Striped = 23
        Tartan = 65
        Corduroy = 78
    End Enum 'Styles
    
    Public Shared Sub Main()
        
        Console.WriteLine("The values of the Colors Enum are:")
        Dim i As Integer
        For Each i In  [Enum].GetValues(GetType(Colors))
            Console.WriteLine(i)
        Next

        Console.WriteLine()
        
        Console.WriteLine("The values of the Styles Enum are:")
        For Each i In  [Enum].GetValues(GetType(Styles))
            Console.WriteLine(i)
        Next
    End Sub 
End Class 
' The example produces the following output:
'       The values of the Colors Enum are:
'       0
'       1
'       2
'       3
'       
'       The values of the Styles Enum are:
'       0
'       23
'       65
'       78

Comentários

Os elementos da matriz são classificados pelos valores binários das constantes de enumeração (ou seja, por sua magnitude não assinada). O exemplo a seguir exibe informações sobre a matriz retornada pelo GetValues método para uma enumeração que inclui um valor negativo, zero e um valor positivo.

using System;

enum SignMagnitude { Negative = -1, Zero = 0, Positive = 1 };

public class Example
{
   public static void Main()
   {
      foreach (var value in Enum.GetValues(typeof(SignMagnitude))) {
         Console.WriteLine("{0,3}     0x{0:X8}     {1}",
                           (int) value, ((SignMagnitude) value));
}   }
}
// The example displays the following output:
//         0     0x00000000     Zero
//         1     0x00000001     Positive
//        -1     0xFFFFFFFF     Negative
open System

type SignMagnitude =
    | Negative = -1
    | Zero = 0
    | Positive = 1

for value in Enum.GetValues typeof<SignMagnitude> do
    printfn $"{value :?> int,3}     0x{value :?> int:X8}     {value :?> SignMagnitude}"
// The example displays the following output:
//         0     0x00000000     Zero
//         1     0x00000001     Positive
//        -1     0xFFFFFFFF     Negative
Public Enum SignMagnitude As Integer
   Negative = -1 
   Zero = 0
   Positive = 1
End Enum
   
Module Example
   Public Sub Main()
      Dim values() As Integer = CType([Enum].GetValues(GetType(SignMagnitude)), Integer())
      For Each value In values
         Console.WriteLine("{0,3}     0x{0:X8}     {1}",
                           value, CType(value, SignMagnitude).ToString())
      Next
   End Sub
End Module
' The example displays the following output:
'      0     0x00000000     Zero
'      1     0x00000001     Positive
'     -1     0xFFFFFFFF     Negative

O GetValues método retorna uma matriz que contém um valor para cada membro da enumType enumeração. Se vários membros tiverem o mesmo valor, a matriz retornada incluirá valores duplicados. Nesse caso, chamar o GetName método com cada valor na matriz retornada não restaura os nomes exclusivos atribuídos aos membros que têm valores duplicados. Para recuperar todos os nomes de membros de enumeração com êxito, chame o GetNames método .

O GetValues método não pode ser invocado usando reflexão em um contexto somente reflexão. Em vez disso, você pode recuperar o valor de todos os membros de enumeração usando o Type.GetFields método para obter uma matriz de FieldInfo objetos que representam membros de enumeração e, em seguida, chamar o FieldInfo.GetRawConstantValue método em cada elemento da matriz. O exemplo a seguir ilustra essa técnica. Ele requer que você defina a seguinte enumeração em um assembly chamado Enumerations.dll:

[Flags] enum Pets { None=0, Dog=1, Cat=2, Rodent=4, Bird=8,
                    Fish=16, Reptile=32, Other=64 };
[<Flags>] 
type Pets =
    | None = 0
    | Dog = 1
    | Cat = 2
    | Rodent = 4
    | Bird = 8
    | Fish = 16
    | Reptile = 32
    | Other = 64
<Flags> Public Enum Pets As Integer
   None = 0
   Dog = 1
   Cat = 2
   Rodent = 4
   Bird = 8
   Fish = 16
   Reptile = 32
   Other = 64
End Enum

O assembly é carregado em um contexto somente reflexão, um Type objeto que representa a Pets enumeração é instanciado, uma matriz de FieldInfo objetos é recuperada e os valores de campo são exibidos no console.

using System;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      Assembly assem = Assembly.ReflectionOnlyLoadFrom(@".\Enumerations.dll");
      Type typ = assem.GetType("Pets");
      FieldInfo[] fields = typ.GetFields();

      foreach (var field in fields) {
         if (field.Name.Equals("value__")) continue;

         Console.WriteLine("{0,-9} {1}", field.Name + ":",
                                         field.GetRawConstantValue());
      }
   }
}
// The example displays the following output:
//       None:     0
//       Dog:      1
//       Cat:      2
//       Rodent:   4
//       Bird:     8
//       Fish:     16
//       Reptile:  32
//       Other:    64
open System
open System.Reflection

let assem = Assembly.ReflectionOnlyLoadFrom @".\Enumerations.dll"
let typ = assem.GetType "Pets"
let fields = typ.GetFields()

for field in fields do
    if not (field.Name.Equals "value__") then

        printfn $"""{field.Name + ":",-9} {field.GetRawConstantValue()}"""
// The example displays the following output:
//       None:     0
//       Dog:      1
//       Cat:      2
//       Rodent:   4
//       Bird:     8
//       Fish:     16
//       Reptile:  32
//       Other:    64
Imports System.Reflection

Module Example
   Public Sub Main()
      Dim assem As Assembly = Assembly.ReflectionOnlyLoadFrom(".\Enumerations.dll")
      Dim typ As Type = assem.GetType("Pets")
      Dim fields As FieldInfo() = typ.GetFields

      For Each field In fields
         If field.Name.Equals("value__") Then Continue For
          
         Console.WriteLine("{0,-9} {1}", field.Name + ":", 
                                         field.GetRawConstantValue())
      Next
   End Sub
End Module
' The example displays the following output:
'       None:     0
'       Dog:      1
'       Cat:      2
'       Rodent:   4
'       Bird:     8
'       Fish:     16
'       Reptile:  32
'       Other:    64

Aplica-se a

GetValues<TEnum>()

Origem:
Enum.cs
Origem:
Enum.cs
Origem:
Enum.cs

Recupera uma matriz de valores de constantes em um tipo de enumeração especificado.

public:
generic <typename TEnum>
 where TEnum : value class static cli::array <TEnum> ^ GetValues();
public static TEnum[] GetValues<TEnum> () where TEnum : struct;
static member GetValues : unit -> 'Enum[] (requires 'Enum : struct)
Public Shared Function GetValues(Of TEnum As Structure) () As TEnum()

Parâmetros de tipo

TEnum

O tipo da enumeração.

Retornos

TEnum[]

Uma matriz que contém os valores das constantes em TEnum.

Exceções

.NET 8 e versões posteriores: TEnum é um tipo de enumeração com suporte booliano.

Aplica-se a