Enum.GetValues Método
Definición
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í.
Sobrecargas
| GetValues(Type) |
Recupera una matriz con los valores de las constantes de una enumeración especificada. |
| GetValues<TEnum>() |
Recupera una matriz con los valores de las constantes de un tipo de enumeración especificado. |
GetValues(Type)
- Source:
- Enum.cs
- Source:
- Enum.cs
- Source:
- Enum.cs
Recupera una matriz con los valores de las constantes de 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 -> ArrayPublic Shared Function GetValues (enumType As Type) As ArrayParámetros
- enumType
- Type
Tipo de enumeración.
Devoluciones
Matriz que contiene los valores de las constantes de enumType.
- Atributos
Excepciones
enumType es null.
enumType no es Enum.
El método se invoca por 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.
.NET 8 y versiones posteriores: enumType es un tipo de enumeración con respaldo booleano.
Ejemplos
En el siguiente ejemplo se muestra el 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
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 correctamente todos los nombres de los miembros de enumeración, llame al GetNames método .
El GetValues método no se puede invocar 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 se muestran los valores de campo 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
GetValues<TEnum>()
- Source:
- Enum.cs
- Source:
- Enum.cs
- Source:
- Enum.cs
Recupera una matriz con los valores de las constantes de un tipo de enumeración 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
Tipo de la enumeración.
Devoluciones
Matriz que contiene los valores de las constantes de TEnum.
Excepciones
.NET 8 y versiones posteriores: TEnum es un tipo de enumeración con respaldo booleano.
Se aplica a
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de