Enum Clase

Definición

Proporciona la clase base para las enumeraciones.Provides the base class for enumerations.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible
Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, IFormattable
Herencia
Derivado
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra cómo usar una enumeración para representar valores con nombre y otra enumeración para representar campos de bits con nombre.The following example demonstrates using an enumeration to represent named values and another enumeration to represent named bit fields.

using namespace System;
enum class Days
{
   Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday
};

enum class BoilingPoints
{
   Celsius = 100,
   Fahrenheit = 212
};

[Flags]

enum class Colors
{
   Red = 1,
   Green = 2,
   Blue = 4,
   Yellow = 8
};

int main()
{
   Type^ weekdays = Days::typeid;
   Type^ boiling = BoilingPoints::typeid;
   Console::WriteLine(  "The days of the week, and their corresponding values in the Days Enum are:" );
   Array^ a = Enum::GetNames( weekdays );
   Int32 i = 0;
   do
   {
      Object^ o = a->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( weekdays, Enum::Parse( weekdays, o->ToString() ),  "d" ) );
   }
   while ( ++i < a->Length );

   Console::WriteLine();
   Console::WriteLine(  "Enums can also be created which have values that represent some meaningful amount." );
   Console::WriteLine(  "The BoilingPoints Enum defines the following items, and corresponding values:" );
   i = 0;
   Array^ b = Enum::GetNames( boiling );
   do
   {
      Object^ o = b->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( boiling, Enum::Parse( boiling, o->ToString() ),  "d" ) );
   }
   while ( ++i < b->Length );

   Array^ c = Enum::GetNames( Colors::typeid );
   Colors myColors = Colors::Red | Colors::Blue | Colors::Yellow;
   Console::WriteLine();
   Console::Write(  "myColors holds a combination of colors. Namely:" );
   for ( i = 0; i < 3; i++ )
      Console::Write(  " {0}", c->GetValue( i ) );
}
using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [Flags]
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static void Main() {

        Type weekdays = typeof(Days);
        Type boiling = typeof(BoilingPoints);

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:");

        foreach ( string s in Enum.GetNames(weekdays) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format( weekdays, Enum.Parse(weekdays, s), "d"));

        Console.WriteLine();
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.");
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:");

        foreach ( string s in Enum.GetNames(boiling) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format(boiling, Enum.Parse(boiling, s), "d"));

        Colors myColors = Colors.Red | Colors.Blue | Colors.Yellow;
        Console.WriteLine();
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors);
    }
}
Public Class EnumTest
    Enum Days
        Saturday
        Sunday
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
    End Enum 
    
    Enum BoilingPoints
        Celsius = 100
        Fahrenheit = 212
    End Enum 
    
    <Flags()> _
    Enum Colors
        Red = 1
        Green = 2
        Blue = 4
        Yellow = 8
    End Enum 

    Public Shared Sub Main()
        Dim weekdays As Type = GetType(Days)
        Dim boiling As Type = GetType(BoilingPoints)

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:")

        Dim s As String
        For Each s In  [Enum].GetNames(weekdays)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(weekdays, [Enum].Parse(weekdays, s), "d"))
        
        Next s
        Console.WriteLine()
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.")
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:")

        For Each s In  [Enum].GetNames(boiling)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(boiling, [Enum].Parse(boiling, s), "d"))
        Next s

        Dim myColors As Colors = Colors.Red Or Colors.Blue Or Colors.Yellow
        Console.WriteLine()
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors)
    End Sub 
End Class 

Comentarios

Una enumeración es un conjunto de constantes con nombre cuyo tipo subyacente es cualquier tipo entero.An enumeration is a set of named constants whose underlying type is any integral type. Si no se declara ningún tipo subyacente explícitamente, se utiliza Int32.If no underlying type is explicitly declared, Int32 is used. Enum es la clase base para todas las enumeraciones en el .NET Framework.Enum is the base class for all enumerations in the .NET Framework. Los tipos de enumeración se definen mediante la C# palabra clave enum en y la construcción Enum...End Enum en Visual Basic.Enumeration types are defined by the enum keyword in C# and the Enum...End Enum construct in Visual Basic.

Enum proporciona métodos para comparar instancias de esta clase, convertir el valor de una instancia en su representación de cadena, convertir la representación de cadena de un número en una instancia de esta clase y crear una instancia de una enumeración especificada. y el valor.Enum provides methods for comparing instances of this class, converting the value of an instance to its string representation, converting the string representation of a number to an instance of this class, and creating an instance of a specified enumeration and value.

También puede tratar una enumeración como un campo de bits.You can also treat an enumeration as a bit field. Para obtener más información, vea la sección miembros no exclusivos y el atributo Flags y el FlagsAttribute tema.For more information, see the Non-Exclusive Members and the Flags Attribute section and the FlagsAttribute topic.

En este tema:In this topic:

Crear un tipo de enumeración Creating an enumeration type
Crear instancias de un tipo de enumeración Instantiating an enumeration type
Prácticas recomendadas de enumeración Enumeration best practices
Realización de operaciones con enumeraciones Performing operations with enumerations
Realizar conversionesPerforming conversions
Analizar valores de enumeraciónParsing enumeration values
Aplicar formato a los valores de enumeraciónFormatting enumeration values
Iterar miembros de enumeraciónIterating enumeration members
Miembros no exclusivos y el atributo FlagsNon-exclusive members and the Flags attribute
Agregar métodos de enumeraciónAdding enumeration methods

Crear un tipo de enumeraciónCreating an enumeration type

Los lenguajes de programación proporcionan normalmente sintaxis para declarar una enumeración que consta de un conjunto de constantes con nombre y sus valores.Programming languages typically provide syntax to declare an enumeration that consists of a set of named constants and their values. En el ejemplo siguiente se muestra la sintaxis utilizada C# por y Visual Basic para definir una enumeración.The following example illustrates the syntax used by C# and Visual Basic to define an enumeration. Crea una enumeración denominada ArrivalStatus que tiene tres miembros: ArrivalStatus.Early, ArrivalStatus.OnTimey ArrivalStatus.Late.It creates an enumeration named ArrivalStatus that has three members: ArrivalStatus.Early, ArrivalStatus.OnTime, and ArrivalStatus.Late. Tenga en cuenta que, en ambos casos, la enumeración no hereda explícitamente de Enum; el compilador controla implícitamente la relación de herencia.Note that in both cases, the enumeration does not explicitly inherit from Enum; the inheritance relationship is handled implicitly by the compiler.

public enum ArrivalStatus { Late=-1, OnTime=0, Early=1 };
Public Enum ArrivalStatus As Integer
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Advertencia

Nunca debe crear un tipo de enumeración cuyo tipo subyacente sea no integral o Char.You should never create an enumeration type whose underlying type is non-integral or Char. Aunque puede crear este tipo de enumeración mediante reflexión, las llamadas a métodos que usan el tipo resultante no son confiables y también pueden producir excepciones adicionales.Although you can create such an enumeration type by using reflection, method calls that use the resulting type are unreliable and may also throw additional exceptions.

Crear instancias de un tipo de enumeraciónInstantiating an enumeration type

Puede crear instancias de un tipo de enumeración del mismo modo que crea una instancia de cualquier otro tipo de valor: declarando una variable y asignando una de las constantes de la enumeración a ella.You can instantiate an enumeration type just as you instantiate any other value type: by declaring a variable and assigning one of the enumeration's constants to it. En el ejemplo siguiente se crea una instancia de un ArrivalStatus cuyo valor es ArrivalStatus.OnTime.The following example instantiates an ArrivalStatus whose value is ArrivalStatus.OnTime.

public class Example
{
   public static void Main()
   {
      ArrivalStatus status = ArrivalStatus.OnTime;
      Console.WriteLine("Arrival Status: {0} ({0:D})", status);
   }
}
// The example displays the following output:
//       Arrival Status: OnTime (0)
Public Module Example
   Public Sub Main()
      Dim status As ArrivalStatus = ArrivalStatus.OnTime
      Console.WriteLine("Arrival Status: {0} ({0:D})", status)
   End Sub
End Module
' The example displays the following output:
'        Arrival Status: OnTime (0)

También puede crear instancias de un valor de enumeración de las siguientes maneras:You can also instantiate an enumeration value in the following ways:

  • Mediante el uso de las características de un lenguaje de programación determinado para C#convertir (como en) o convertir (como en Visual Basic) un valor entero en un valor de enumeración.By using a particular programming language's features to cast (as in C#) or convert (as in Visual Basic) an integer value to an enumeration value. En el ejemplo siguiente se crea un objeto de ArrivalStatus cuyo valor se ArrivalStatus.Early de esta manera.The following example creates an ArrivalStatus object whose value is ArrivalStatus.Early in this way.

    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    Dim status2 As ArrivalStatus = CType(1, ArrivalStatus)
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2)
    ' The example displays the following output:
    '       Arrival Status: Early (1)
    
  • Llamando a su constructor sin parámetros implícito.By calling its implicit parameterless constructor. Como se muestra en el ejemplo siguiente, en este caso el valor subyacente de la instancia de enumeración es 0.As the following example shows, in this case the underlying value of the enumeration instance is 0. Sin embargo, esto no es necesariamente el valor de una constante válida en la enumeración.However, this is not necessarily the value of a valid constant in the enumeration.

    ArrivalStatus status1 = new ArrivalStatus();
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
    // The example displays the following output:
    //       Arrival Status: OnTime (0)
    
    Dim status1 As New ArrivalStatus()
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1)
    ' The example displays the following output:
    '        Arrival Status: OnTime (0)
    
  • Llamando al método Parse o TryParse para analizar una cadena que contiene el nombre de una constante de la enumeración.By calling the Parse or TryParse method to parse a string that contains the name of a constant in the enumeration. Para obtener más información, vea la sección analizar valores de enumeración .For more information, see the Parsing Enumeration Values section.

  • Llamando al método ToObject para convertir un valor entero en un tipo de enumeración.By calling the ToObject method to convert an integral value to an enumeration type. Para obtener más información, consulte la sección realizar conversiones .For more information, see the Performing Conversions section.

Prácticas recomendadas de enumeraciónEnumeration best practices

Se recomienda utilizar los siguientes procedimientos recomendados al definir tipos de enumeración:We recommend that you use the following best practices when you define enumeration types:

  • Si no ha definido un miembro de enumeración cuyo valor es 0, considere la posibilidad de crear un None constante enumerada.If you have not defined an enumeration member whose value is 0, consider creating a None enumerated constant. De forma predeterminada, la memoria usada para la enumeración se inicializa en cero por el Common Language Runtime.By default, the memory used for the enumeration is initialized to zero by the common language runtime. Por consiguiente, si no define una constante cuyo valor es cero, la enumeración contendrá un valor no válido cuando se cree.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • Si hay un caso predeterminado obvio que la aplicación tiene que representar, considere la posibilidad de usar una constante enumerada cuyo valor sea cero para representarla.If there is an obvious default case that your application has to represent, consider using an enumerated constant whose value is zero to represent it. Si no hay ningún caso predeterminado, considere la posibilidad de usar una constante enumerada cuyo valor sea cero para especificar el caso que no está representado por ninguna de las demás constantes enumeradas.If there is no default case, consider using an enumerated constant whose value is zero to specify the case that is not represented by any of the other enumerated constants.

  • No especifique constantes enumeradas que estén reservadas para uso futuro.Do not specify enumerated constants that are reserved for future use.

  • Al definir un método o una propiedad que toma una constante enumerada como un valor, considere la posibilidad de validar el valor.When you define a method or property that takes an enumerated constant as a value, consider validating the value. La razón es que puede convertir un valor numérico al tipo de enumeración incluso si ese valor numérico no está definido en la enumeración.The reason is that you can cast a numeric value to the enumeration type even if that numeric value is not defined in the enumeration.

Las prácticas recomendadas adicionales para los tipos de enumeración cuyas constantes son campos de bits se enumeran en la sección miembros no exclusivos y en el atributo Flags .Additional best practices for enumeration types whose constants are bit fields are listed in the Non-Exclusive Members and the Flags Attribute section.

Realizar operaciones con enumeracionesPerforming operations with enumerations

No se pueden definir nuevos métodos al crear una enumeración.You cannot define new methods when you are creating an enumeration. Sin embargo, un tipo de enumeración hereda un conjunto completo de métodos estáticos y de instancia de la clase Enum.However, an enumeration type inherits a complete set of static and instance methods from the Enum class. En las secciones siguientes se revisan la mayoría de estos métodos, además de otros métodos que se suelen usar cuando se trabaja con valores de enumeración.The following sections survey most of these methods, in addition to several other methods that are commonly used when working with enumeration values.

Realizar conversionesPerforming conversions

Puede convertir entre un miembro de enumeración y su tipo subyacente mediante un operador de conversión C#(en) o de conversión (en Visual Basic).You can convert between an enumeration member and its underlying type by using a casting (in C#) or conversion (in Visual Basic) operator. En el ejemplo siguiente se utilizan los operadores de conversión o conversión para realizar conversiones de un entero a un valor de enumeración y de un valor de enumeración a un entero.The following example uses casting or conversion operators to perform conversions both from an integer to an enumeration value and from an enumeration value to an integer.

int value3 = 2;
ArrivalStatus status3 = (ArrivalStatus) value3;

int value4 = (int) status3;
Dim value3 As Integer = 2
Dim status3 As ArrivalStatus = CType(value3, ArrivalStatus)

Dim value4 As Integer = CInt(status3)

La clase Enum también incluye un método ToObject que convierte un valor de cualquier tipo entero en un valor de enumeración.The Enum class also includes a ToObject method that converts a value of any integral type to an enumeration value. En el ejemplo siguiente se usa el método ToObject(Type, Int32) para convertir un Int32 en un valor de ArrivalStatus.The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. Tenga en cuenta que, dado que el ToObject devuelve un valor de tipo Object, el uso de un operador de conversión o conversión puede seguir siendo necesario para convertir el objeto al tipo de enumeración.Note that, because the ToObject returns a value of type Object, the use of a casting or conversion operator may still be necessary to cast the object to the enumeration type.

int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);
Dim number As Integer = -1
Dim arrived As ArrivalStatus = CType(ArrivalStatus.ToObject(GetType(ArrivalStatus), number), ArrivalStatus)

Al convertir un entero en un valor de enumeración, es posible asignar un valor que no sea realmente un miembro de la enumeración.When converting an integer to an enumeration value, it is possible to assign a value that is not actually a member of the enumeration. Para evitarlo, puede pasar el entero al método IsDefined antes de realizar la conversión.To prevent this, you can pass the integer to the IsDefined method before performing the conversion. En el ejemplo siguiente se usa este método para determinar si los elementos de una matriz de valores enteros se pueden convertir en valores ArrivalStatus.The following example uses this method to determine whether the elements in an array of integer values can be converted to ArrivalStatus values.

using System;

public enum ArrivalStatus { Unknown=-3, Late=-1, OnTime=0, Early=1 };

public class Example
{
   public static void Main()
   {
      int[] values = { -3, -1, 0, 1, 5, Int32.MaxValue };
      foreach (var value in values)
      {
         ArrivalStatus status;
         if (Enum.IsDefined(typeof(ArrivalStatus), value))
            status = (ArrivalStatus) value;
         else
            status = ArrivalStatus.Unknown;
         Console.WriteLine("Converted {0:N0} to {1}", value, status);
      }
   }
}
// The example displays the following output:
//       Converted -3 to Unknown
//       Converted -1 to Late
//       Converted 0 to OnTime
//       Converted 1 to Early
//       Converted 5 to Unknown
//       Converted 2,147,483,647 to Unknown
Public Enum ArrivalStatus As Integer
   Unknown = -3
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Module Example
   Public Sub Main()
      Dim values() As Integer = { -3, -1, 0, 1, 5, Int32.MaxValue }
      For Each value In values
         Dim status As ArrivalStatus
         If [Enum].IsDefined(GetType(ArrivalStatus), value)
            status = CType(value, ArrivalStatus) 
         Else
            status = ArrivalStatus.Unknown
         End If
         Console.WriteLine("Converted {0:N0} to {1}", value, status)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Converted -3 to Unknown
'       Converted -1 to Late
'       Converted 0 to OnTime
'       Converted 1 to Early
'       Converted 5 to Unknown
'       Converted 2,147,483,647 to Unknown

Aunque la clase Enum proporciona implementaciones de interfaz explícitas de la interfaz IConvertible para convertir de un valor de enumeración a un tipo entero, debe utilizar los métodos de la clase Convert, como ToInt32, para realizar estas conversiones.Although the Enum class provides explicit interface implementations of the IConvertible interface for converting from an enumeration value to an integral type, you should use the methods of the Convert class, such as ToInt32, to perform these conversions. En el ejemplo siguiente se muestra cómo puede utilizar el método GetUnderlyingType junto con el método Convert.ChangeType para convertir un valor de enumeración en su tipo subyacente.The following example illustrates how you can use the GetUnderlyingType method along with the Convert.ChangeType method to convert an enumeration value to its underlying type. Tenga en cuenta que en este ejemplo no es necesario conocer el tipo subyacente de la enumeración en tiempo de compilación.Note that this example does not require the underlying type of the enumeration to be known at compile time.

ArrivalStatus status = ArrivalStatus.Early;
var number = Convert.ChangeType(status, Enum.GetUnderlyingType(typeof(ArrivalStatus)));
Console.WriteLine("Converted {0} to {1}", status, number);
// The example displays the following output:
//       Converted Early to 1
Dim status As ArrivalStatus = ArrivalStatus.Early
Dim number = Convert.ChangeType(status, [Enum].GetUnderlyingType(GetType(ArrivalStatus)))
Console.WriteLine("Converted {0} to {1}", status, number)
' The example displays the following output:
'       Converted Early to 1

Analizar valores de enumeraciónParsing enumeration values

Los métodos Parse y TryParse permiten convertir la representación de cadena de un valor de enumeración en ese valor.The Parse and TryParse methods allow you to convert the string representation of an enumeration value to that value. La representación de cadena puede ser el nombre o el valor subyacente de una constante de enumeración.The string representation can be either the name or the underlying value of an enumeration constant. Tenga en cuenta que los métodos de análisis convertirán correctamente representaciones de cadena de números que no son miembros de una enumeración determinada si las cadenas se pueden convertir en un valor del tipo subyacente de la enumeración.Note that the parsing methods will successfully convert string representations of numbers that are not members of a particular enumeration if the strings can be converted to a value of the enumeration's underlying type. Para evitar esto, se puede llamar al método IsDefined para asegurarse de que el resultado del método de análisis es un valor de enumeración válido.To prevent this, the IsDefined method can be called to ensure that the result of the parsing method is a valid enumeration value. En el ejemplo se muestra este enfoque y se muestran las llamadas a los métodos Parse(Type, String) y Enum.TryParse<TEnum>(String, TEnum).The example illustrates this approach and demonstrates calls to both the Parse(Type, String) and Enum.TryParse<TEnum>(String, TEnum) methods. Tenga en cuenta que el método de análisis no genérico devuelve un objeto que puede tener que convertir ( C#en) o convertir (en Visual Basic) en el tipo de enumeración adecuado.Note that the non-generic parsing method returns an object that you may have to cast (in C#) or convert (in Visual Basic) to the appropriate enumeration type.

string number = "-1";
string name = "Early";

try {
   ArrivalStatus status1 = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), number);
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status1)))
      status1 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", number, status1);
}
catch (FormatException) {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}   
   
ArrivalStatus status2;
if (Enum.TryParse<ArrivalStatus>(name, out status2)) {
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status2)))
      status2 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", name, status2);
}
else {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}
// The example displays the following output:
//       Converted '-1' to Late
//       Converted 'Early' to Early
Dim number As String = "-1"
Dim name As String = "Early"
Dim invalid As String = "32"

Try 
   Dim status1 As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), number), ArrivalStatus)
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status1) Then status1 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", number, status1)
Catch e As FormatException
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End Try   
   
Dim status2 As ArrivalStatus
If [Enum].TryParse(Of ArrivalStatus)(name, status2) Then
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status2) Then status2 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", name, status2)
Else
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End If
' The example displays the following output:
'       Converted '-1' to Late
'       Converted 'Early' to Early

Aplicar formato a los valores de enumeraciónFormatting enumeration values

Puede convertir los valores de enumeración en sus representaciones de cadena llamando al método estático Format, así como a las sobrecargas del método ToString de instancia.You can convert enumeration values to their string representations by calling the static Format method, as well as the overloads of the instance ToString method. Puede utilizar una cadena de formato para controlar la manera precisa en la que un valor de enumeración se representa como una cadena.You can use a format string to control the precise way in which an enumeration value is represented as a string. Para obtener más información, vea cadenas de formato de enumeración.For more information, see Enumeration Format Strings. En el ejemplo siguiente se usa cada una de las cadenas de formato de enumeración admitidas ("G" o "g", "D" o "d", "X" o "x" y "F" o "f") para convertir un miembro de la enumeración ArrivalStatus en sus representaciones de cadena.The following example uses each of the supported enumeration format strings ("G" or "g", "D" or "d", "X" or "x", and "F" or "f" ) to convert a member of the ArrivalStatus enumeration to its string representations.

string[] formats= { "G", "F", "D", "X"};
ArrivalStatus status = ArrivalStatus.Late;
foreach (var fmt in formats)
   Console.WriteLine(status.ToString(fmt));

// The example displays the following output:
//       Late
//       Late
//       -1
//       FFFFFFFF
Dim formats() As String = { "G", "F", "D", "X"}
Dim status As ArrivalStatus = ArrivalStatus.Late
For Each fmt As String In formats
   Console.WriteLine(status.ToString(fmt))
Next
' The example displays the following output:
'       Late
'       Late
'       -1
'       FFFFFFFF

Iterar miembros de enumeraciónIterating enumeration members

El tipo de Enum no implementa la interfaz IEnumerable o IEnumerable<T>, lo que le permitiría iterar a los miembros de una colección mediante el uso C#de una construcción foreach (in) o For Each (en Visual Basic).The Enum type does not implement the IEnumerable or IEnumerable<T> interface, which would enable you to iterate members of a collection by using a foreach (in C#) or For Each (in Visual Basic) construct. Sin embargo, puede enumerar los miembros de una de estas dos maneras.However, you can enumerate members in either of two ways.

  • Puede llamar al método GetNames para recuperar una matriz de cadenas que contenga los nombres de los miembros de la enumeración.You can call the GetNames method to retrieve a string array containing the names of the enumeration members. A continuación, para cada elemento de la matriz de cadenas, puede llamar al método Parse para convertir la cadena en su valor de enumeración equivalente.Next, for each element of the string array, you can call the Parse method to convert the string to its equivalent enumeration value. En el ejemplo siguiente se muestra este enfoque.The following example illustrates this approach.

    string[] names = Enum.GetNames(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    Array.Sort(names);
    foreach (var name in names) {
       ArrivalStatus status = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), name);
       Console.WriteLine("   {0} ({0:D})", status);
    }
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          Early (1)
    //          Late (-1)
    //          OnTime (0)
    //          Unknown (-3)      
    
    Dim names() As String = [Enum].GetNames(GetType(ArrivalStatus))
    Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
    Array.Sort(names)
    For Each name In names
       Dim status As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), name),
                                     ArrivalStatus)
       Console.WriteLine("   {0} ({0:D})", status)
    Next
    ' The example displays the following output:
    '       Members of ArrivalStatus:
    '          Early (1)
    '          Late (-1)
    '          OnTime (0)
    '          Unknown (-3)      
    
  • Puede llamar al método GetValues para recuperar una matriz que contenga los valores subyacentes en la enumeración.You can call the GetValues method to retrieve an array that contains the underlying values in the enumeration. A continuación, para cada elemento de la matriz, puede llamar al método ToObject para convertir el entero en su valor de enumeración equivalente.Next, for each element of the array, you can call the ToObject method to convert the integer to its equivalent enumeration value. En el ejemplo siguiente se muestra este enfoque.The following example illustrates this approach.

    var values = Enum.GetValues(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    foreach (ArrivalStatus status in values) {
       Console.WriteLine("   {0} ({0:D})", status);
    }                                       
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          OnTime (0)
    //          Early (1)
    //          Unknown (-3)
    //          Late (-1)
    
    Dim values = [Enum].GetValues(GetType(ArrivalStatus))
    Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
    For Each value In values
       Dim status As ArrivalStatus = CType([Enum].ToObject(GetType(ArrivalStatus), value),
                                           ArrivalStatus)
       Console.WriteLine("   {0} ({0:D})", status)
    Next                                       
    ' The example displays the following output:
    '       Members of ArrivalStatus:
    '          OnTime (0)
    '          Early (1)
    '          Unknown (-3)
    '          Late (-1)
    

Miembros no exclusivos y el atributo FlagsNon-exclusive members and the Flags attribute

Un uso común de una enumeración es representar un conjunto de valores mutuamente excluyentes.One common use of an enumeration is to represent a set of mutually exclusive values. Por ejemplo, una instancia de ArrivalStatus puede tener un valor de Early, OnTimeo Late.For example, an ArrivalStatus instance can have a value of Early, OnTime, or Late. No tiene sentido que el valor de una instancia de ArrivalStatus refleje más de una constante de enumeración.It makes no sense for the value of an ArrivalStatus instance to reflect more than one enumeration constant.

En otros casos, sin embargo, el valor de un objeto de enumeración puede incluir varios miembros de enumeración y cada miembro representa un campo de bits en el valor de enumeración.In other cases, however, the value of an enumeration object can include multiple enumeration members, and each member represents a bit field in the enumeration value. El atributo FlagsAttribute se puede utilizar para indicar que la enumeración consta de campos de bits.The FlagsAttribute attribute can be used to indicate that the enumeration consists of bit fields. Por ejemplo, una enumeración denominada Pets podría usarse para indicar los tipos de mascotas de un hogar.For example, an enumeration named Pets might be used to indicate the kinds of pets in a household. Se puede definir de la siguiente manera.It can be defined as follows.

[Flags] public enum Pets { None=0, Dog=1, Cat=2, Bird=4, Rodent=8,
                           Reptile=16, Other=32 };

<Flags> Public Enum Pets As Integer
   None = 0
   Dog = 1
   Cat = 2
   Bird = 4
   Rodent = 8
   Reptile = 16
   Other = 32
End Enum

A continuación, se puede usar la enumeración Pets como se muestra en el ejemplo siguiente.The Pets enumeration can then be used as shown in the following example.

Pets familyPets = Pets.Dog | Pets.Cat;
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets);
// The example displays the following output:
//       Pets: Dog, Cat (3)      
Dim familyPets As Pets = Pets.Dog Or Pets.Cat
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets)
' The example displays the following output:
'       Pets: Dog, Cat (3)      

Se deben usar los siguientes procedimientos recomendados al definir una enumeración bit a bit y aplicar el FlagsAttribute atributo.The following best practices should be used when defining a bitwise enumeration and applying the FlagsAttribute attribute.

  • Use el FlagsAttribute atributo personalizado para una enumeración solo si se va a realizar una operación bit a bit (AND, OR, EXCLUSIVe OR) en un valor numérico.Use the FlagsAttribute custom attribute for an enumeration only if a bitwise operation (AND, OR, EXCLUSIVE OR) is to be performed on a numeric value.

  • Defina las constantes de enumeración en potencias de dos, es decir, 1, 2, 4, 8, etc.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. Esto significa que las marcas individuales de las constantes de enumeración combinada no se superponen.This means the individual flags in combined enumeration constants do not overlap.

  • Considere la posibilidad de crear una constante enumerada para combinaciones de marcas de uso frecuente.Consider creating an enumerated constant for commonly used flag combinations. Por ejemplo, si tiene una enumeración que se usa para las operaciones de e/s de archivo que contienen las constantes enumeradas Read = 1 y Write = 2, considere la posibilidad de crear la constante enumerada ReadWrite = Read OR Write, que combina las marcas Read y Write.For example, if you have an enumeration used for file I/O operations that contains the enumerated constants Read = 1 and Write = 2, consider creating the enumerated constant ReadWrite = Read OR Write, which combines the Read and Write flags. Además, la operación OR bit a bit usada para combinar las marcas puede considerarse un concepto avanzado en algunas circunstancias que no se deben requerir para tareas sencillas.In addition, the bitwise OR operation used to combine the flags might be considered an advanced concept in some circumstances that should not be required for simple tasks.

  • Tenga precaución si define un número negativo como una constante enumerada de marca porque muchas posiciones de marca se pueden establecer en 1, lo que podría hacer que el código sea confuso y fomentar errores de codificación.Use caution if you define a negative number as a flag enumerated constant because many flag positions might be set to 1, which might make your code confusing and encourage coding errors.

  • Una manera cómoda de probar si una marca está establecida en un valor numérico es llamar a la instancia HasFlag método, como se muestra en el ejemplo siguiente.A convenient way to test whether a flag is set in a numeric value is to call the instance HasFlag method, as shown in the following example.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets.HasFlag(Pets.Dog))
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.      
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets.HasFlag(Pets.Dog) Then
       Console.WriteLine("The family has a dog.")
    End If
    ' The example displays the following output:
    '       The family has a dog.      
    

    Es equivalente a realizar una operación and bit a bit entre el valor numérico y la constante enumerada de la marca, que establece todos los bits del valor numérico en cero que no se corresponden con la marca y, a continuación, prueba si el resultado de esa operación es igual a la propiedad marcar constante enumerada.It is equivalent to performing a bitwise AND operation between the numeric value and the flag enumerated constant, which sets all bits in the numeric value to zero that do not correspond to the flag, and then testing whether the result of that operation is equal to the flag enumerated constant. Esto se muestra en el ejemplo siguiente.This is illustrated in the following example.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if ((familyPets & Pets.Dog) == Pets.Dog)
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.      
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets And Pets.Dog = Pets.Dog Then
       Console.WriteLine("The family has a dog.")
    End If   
    ' The example displays the following output:
    '       The family has a dog.      
    
  • Use None como el nombre de la constante enumerada de marca cuyo valor es cero.Use None as the name of the flag enumerated constant whose value is zero. No se puede usar la None constante enumerada en una operación and bit a bit para probar una marca porque el resultado siempre es cero.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. Sin embargo, puede realizar una comparación lógica, no bit a bit, entre el valor numérico y el None constante enumerada para determinar si se ha establecido algún bit en el valor numérico.However, you can perform a logical, not a bitwise, comparison between the numeric value and the None enumerated constant to determine whether any bits in the numeric value are set. Esto se muestra en el ejemplo siguiente.This is illustrated in the following example.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets == Pets.None)
       Console.WriteLine("The family has no pets.");
    else
       Console.WriteLine("The family has pets.");   
    // The example displays the following output:
    //       The family has pets.      
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets = Pets.None Then
       Console.WriteLine("The family has no pets.")
    Else
       Console.WriteLine("The family has pets.")   
    End If
    ' The example displays the following output:
    '       The family has pets.      
    
  • No defina un valor de enumeración únicamente para reflejar el estado de la propia enumeración.Do not define an enumeration value solely to mirror the state of the enumeration itself. Por ejemplo, no defina una constante enumerada que simplemente marque el final de la enumeración.For example, do not define an enumerated constant that merely marks the end of the enumeration. Si necesita determinar el último valor de la enumeración, compruebe ese valor explícitamente.If you need to determine the last value of the enumeration, check for that value explicitly. Además, puede realizar una comprobación de intervalo para la primera y última constante enumerada si todos los valores del intervalo son válidos.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

Agregar métodos de enumeraciónAdding enumeration methods

Dado que los tipos de enumeración se definen mediante estructuras de lenguajeC#, como enum () y Enum (Visual Basic), no se pueden definir métodos personalizados para un tipo de enumeración que no sean los métodos heredados de la clase Enum.Because enumeration types are defined by language structures, such as enum (C#) and Enum (Visual Basic), you cannot define custom methods for an enumeration type other than those methods inherited from the Enum class. Sin embargo, puede usar métodos de extensión para agregar funcionalidad a un tipo de enumeración determinado.However, you can use extension methods to add functionality to a particular enumeration type.

En el ejemplo siguiente, la enumeración Grades representa las posibles calificaciones con letras que un alumno puede recibir en una clase.In the following example, the Grades enumeration represents the possible letter grades that a student may receive in a class. Un método de extensión denominado Passing se agrega al tipo Grades para que cada instancia de ese tipo "sepa" ahora si representa una calificación de aprobado o no.An extension method named Passing is added to the Grades type so that each instance of that type now "knows" whether it represents a passing grade or not. La clase Extensions también contiene una variable estática de lectura y escritura que define el grado de paso mínimo.The Extensions class also contains a static read-write variable that defines the minimum passing grade. El valor devuelto del método de extensión Passing refleja el valor actual de esa variable.The return value of the Passing extension method reflects the current value of that variable.

using System;

// Define an enumeration to represent student grades.
public enum Grades { F = 0, D = 1, C = 2, B = 3, A = 4 };

// Define an extension method for the Grades enumeration.
public static class Extensions
{        
  public static Grades minPassing = Grades.D;

  public static bool Passing(this Grades grade)
  {
      return grade >= minPassing;
  }
}

class Example
{       
  static void Main()
  {
      Grades g1 = Grades.D;
      Grades g2 = Grades.F;
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");

      Extensions.minPassing = Grades.C;
      Console.WriteLine("\nRaising the bar!\n");
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");
  }
}
// The exmaple displays the following output:
//       D is a passing grade.
//       F is not a passing grade.
//       
//       Raising the bar!
//       
//       D is not a passing grade.
//       F is not a passing grade.
Imports System.Runtime.CompilerServices

' Define an enumeration to represent student grades.
Public Enum Grades As Integer
   F = 0
   D = 1
   C = 2
   B = 3
   A = 4
End Enum   

' Define an extension method for the Grades enumeration.
Public Module Extensions
  Public minPassing As Grades = Grades.D
 
  <Extension>
  Public Function Passing(grade As Grades) As Boolean
     Return grade >= minPassing
  End Function
End Module

Public Module Example
  Public Sub Main()
      Dim g1 As Grades = Grades.D
      Dim g2 As Grades = Grades.F
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
      Console.WriteLine()
      
      Extensions.minPassing = Grades.C
      Console.WriteLine("Raising the bar!")
      Console.WriteLine()
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
  End Sub
End Module
' The exmaple displays the following output:
'       D is a passing grade.
'       F is not a passing grade.
'       
'       Raising the bar!
'       
'       D is not a passing grade.
'       F is not a passing grade.

Constructores

Enum()

Inicializa una nueva instancia de la clase Enum.Initializes a new instance of the Enum class.

Métodos

CompareTo(Object)

Compara esta instancia con un objeto especificado y devuelve una indicación de los valores relativos.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.Returns a value indicating whether this instance is equal to a specified object.

Format(Type, Object, String)

Convierte el valor especificado de un tipo enumerado especificado en la representación de cadena equivalente de acuerdo con el formato especificado.Converts the specified value of a specified enumerated type to its equivalent string representation according to the specified format.

GetHashCode()

Devuelve el código hash del valor de esta instancia.Returns the hash code for the value of this instance.

GetName(Type, Object)

Recupera el nombre de la constante de la enumeración especificada que tiene el valor especificado.Retrieves the name of the constant in the specified enumeration that has the specified value.

GetNames(Type)

Recupera una matriz con los nombres de las constantes de una enumeración especificada.Retrieves an array of the names of the constants in a specified enumeration.

GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
GetTypeCode()

Devuelve el código de tipo del tipo subyacente de este miembro de enumeración.Returns the type code of the underlying type of this enumeration member.

GetUnderlyingType(Type)

Devuelve el tipo subyacente de la enumeración especificada.Returns the underlying type of the specified enumeration.

GetValues(Type)

Recupera una matriz con los valores de las constantes de una enumeración especificada.Retrieves an array of the values of the constants in a specified enumeration.

HasFlag(Enum)

Determina si hay uno o varios campos de bits establecidos en la instancia actual.Determines whether one or more bit fields are set in the current instance.

IsDefined(Type, Object)

Devuelve un booleano que indica si un valor integral especificado, o bien su nombre en forma de cadena, existe en una enumeración especifica.Returns a Boolean telling whether a given integral value, or its name as a string, exists in a specified enumeration.

MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
Parse(Type, String)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

Parse(Type, String, Boolean)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Un parámetro especifica si la operación no distingue mayúsculas de minúsculas.A parameter specifies whether the operation is case-insensitive.

Parse<TEnum>(String)
Parse<TEnum>(String, Boolean)
ToObject(Type, Byte)

Convierte el entero de 8 bits sin signo especificado en un miembro de enumeración.Converts the specified 8-bit unsigned integer to an enumeration member.

ToObject(Type, Int16)

Convierte el entero de 16 bits con signo especificado en un miembro de enumeración.Converts the specified 16-bit signed integer to an enumeration member.

ToObject(Type, Int32)

Convierte el entero de 32 bits con signo especificado en un miembro de enumeración.Converts the specified 32-bit signed integer to an enumeration member.

ToObject(Type, Int64)

Convierte el entero de 64 bits con signo especificado en un miembro de enumeración.Converts the specified 64-bit signed integer to an enumeration member.

ToObject(Type, Object)

Convierte el objeto especificado con un valor entero en un miembro de enumeración.Converts the specified object with an integer value to an enumeration member.

ToObject(Type, SByte)

Convierte el valor entero de 8 bits con signo especificado en un miembro de enumeración.Converts the specified 8-bit signed integer value to an enumeration member.

ToObject(Type, UInt16)

Convierte el valor entero de 16 bits sin signo especificado en un miembro de enumeración.Converts the specified 16-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt32)

Convierte el valor entero de 32 bits sin signo especificado en un miembro de enumeración.Converts the specified 32-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt64)

Convierte el valor entero de 64 bits sin signo especificado en un miembro de enumeración.Converts the specified 64-bit unsigned integer value to an enumeration member.

ToString()

Convierte el valor de esta instancia en la representación de cadena equivalente.Converts the value of this instance to its equivalent string representation.

ToString(IFormatProvider)

Esta sobrecarga del método está en desuso; use ToString().This method overload is obsolete; use ToString().

ToString(String)

Convierte el valor de esta instancia en la representación de cadena equivalente usando el formato especificado.Converts the value of this instance to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

Esta sobrecarga del método está en desuso; use ToString(String).This method overload is obsolete; use ToString(String).

TryParse(Type, String, Boolean, Object)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

TryParse(Type, String, Object)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

TryParse<TEnum>(String, Boolean, TEnum)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Un parámetro especifica si la operación distingue mayúsculas de minúsculas.A parameter specifies whether the operation is case-sensitive. El valor devuelto indica si la conversión se realizó correctamente.The return value indicates whether the conversion succeeded.

TryParse<TEnum>(String, TEnum)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. El valor devuelto indica si la conversión se realizó correctamente.The return value indicates whether the conversion succeeded.

Implementaciones de interfaz explícitas

IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Convierte el valor actual en un valor booleano basado en el tipo subyacente.Converts the current value to a Boolean value based on the underlying type.

IConvertible.ToByte(IFormatProvider)

Convierte el valor actual en un entero de 8 bits sin signo basado en el tipo subyacente.Converts the current value to an 8-bit unsigned integer based on the underlying type.

IConvertible.ToChar(IFormatProvider)

Convierte el valor actual en un carácter Unicode basado en el tipo subyacente.Converts the current value to a Unicode character based on the underlying type.

IConvertible.ToDateTime(IFormatProvider)

Convierte el valor actual en DateTime basado en el tipo subyacente.Converts the current value to a DateTime based on the underlying type.

IConvertible.ToDecimal(IFormatProvider)

Convierte el valor actual en Decimal basado en el tipo subyacente.Converts the current value to a Decimal based on the underlying type.

IConvertible.ToDouble(IFormatProvider)

Convierte el valor actual en número de punto flotante de precisión doble basado en el tipo subyacente.Converts the current value to a double-precision floating point number based on the underlying type.

IConvertible.ToInt16(IFormatProvider)

Convierte el valor actual en un entero de 16 bits con signo basado en el tipo subyacente.Converts the current value to a 16-bit signed integer based on the underlying type.

IConvertible.ToInt32(IFormatProvider)

Convierte el valor actual en un entero de 32 bits con signo basado en el tipo subyacente.Converts the current value to a 32-bit signed integer based on the underlying type.

IConvertible.ToInt64(IFormatProvider)

Convierte el valor actual en un entero de 64 bits con signo basado en el tipo subyacente.Converts the current value to a 64-bit signed integer based on the underlying type.

IConvertible.ToSByte(IFormatProvider)

Convierte el valor actual en un entero de 8 bits con signo basado en el tipo subyacente.Converts the current value to an 8-bit signed integer based on the underlying type.

IConvertible.ToSingle(IFormatProvider)

Convierte el valor actual en un número de punto flotante de precisión sencilla basándose en el tipo subyacente.Converts the current value to a single-precision floating-point number based on the underlying type.

IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider)

Convierte el valor actual en un tipo especificado basado en el tipo subyacente.Converts the current value to a specified type based on the underlying type.

IConvertible.ToUInt16(IFormatProvider)

Convierte el valor actual en un entero de 16 bits sin signo basado en el tipo subyacente.Converts the current value to a 16-bit unsigned integer based on the underlying type.

IConvertible.ToUInt32(IFormatProvider)

Convierte el valor actual en un entero de 32 bits sin signo basado en el tipo subyacente.Converts the current value to a 32-bit unsigned integer based on the underlying type.

IConvertible.ToUInt64(IFormatProvider)

Convierte el valor actual en un entero de 64 bits sin signo basado en el tipo subyacente.Converts the current value to a 64-bit unsigned integer based on the underlying type.

IFormattable.ToString(String, IFormatProvider)

Esta sobrecarga del método está en desuso; use ToString(String).This method overload is obsolete; use ToString(String).

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.This type is thread safe.

Consulte también: