Enum.GetValues(Type) Método

Definición

Espacio de nombres:: System

Ensamblados:: mscorlib.dll, System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Recupera una matriz de los valores de las constantes en una enumeración 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

Tipo de enumeración.

Devoluciones

Array

Matriz que contiene los valores de las constantes en enumType.

Atributos: ComVisibleAttribute

Excepciones

ArgumentNullException

enumType es null.

ArgumentException

enumTypeno es .Enum

InvalidOperationException

El método se invoca mediante la reflexión en un contexto de solo reflexión,

O bien

enumType es un tipo de un ensamblado cargado en un contexto de solo reflexión.

InvalidOperationException

.NET 8 y versiones posteriores: enumType es un tipo de enumeración con respaldo booleano.

Ejemplos

En el ejemplo siguiente se muestra el uso de GetValues.

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

Comentarios

Los elementos de la matriz se ordenan por los valores binarios de las constantes de enumeración (es decir, por su magnitud sin signo). En el ejemplo siguiente se muestra información sobre la matriz devuelta por el GetValues método para una enumeración que incluye un valor negativo, cero y un 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

El GetValues método devuelve una matriz que contiene un valor para cada miembro de la enumType enumeración. Si varios miembros tienen el mismo valor, la matriz devuelta incluye valores duplicados. En este caso, llamar al GetName método con cada valor de la matriz devuelta no restaura los nombres únicos asignados a los miembros que tienen valores duplicados. Para recuperar todos los nombres de los miembros de enumeración correctamente, llame al GetNames método .

No se puede invocar el GetValues método mediante la reflexión en un contexto de solo reflexión. En su lugar, puede recuperar el valor de todos los miembros de enumeración mediante el Type.GetFields método para obtener una matriz de objetos que representan miembros de FieldInfo enumeración y, a continuación, llamar al FieldInfo.GetRawConstantValue método en cada elemento de la matriz. En el ejemplo siguiente se muestra esta técnica. Requiere que defina la enumeración siguiente en un ensamblado denominado 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

El ensamblado se carga en un contexto de solo reflexión, se crea una instancia de un Type objeto que representa la Pets enumeración, se recupera una matriz de FieldInfo objetos y los valores de campo se muestran en la consola.

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

Se aplica a

Comentarios

¿Le ha resultado útil esta página?