Enum Classe

Definição

Fornece a classe base para enumerações.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
Herança
Derivado
Atributos
Implementações

Exemplos

O exemplo a seguir demonstra como usar uma enumeração para representar valores nomeados e outra enumeração para representar campos de bits nomeados.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 

Comentários

Uma enumeração é um conjunto de constantes nomeadas cujo tipo subjacente é qualquer tipo integral.An enumeration is a set of named constants whose underlying type is any integral type. Se nenhum tipo subjacente for declarado explicitamente, Int32 será usado.If no underlying type is explicitly declared, Int32 is used. Enumé a classe base para todas as enumerações no .NET Framework.Enum is the base class for all enumerations in the .NET Framework. Os tipos de enumeração são definidos enum pela palavra C# -chave Enumem e... End Enum construção em Visual Basic.Enumeration types are defined by the enum keyword in C# and the Enum...End Enum construct in Visual Basic.

Enumfornece métodos para comparar instâncias dessa classe, convertendo o valor de uma instância para sua representação de cadeia de caracteres, convertendo a representação de cadeia de caracteres de um número em uma instância dessa classe e criando uma instância de uma enumeração e valor especificados.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.

Você também pode tratar uma enumeração como um campo de bits.You can also treat an enumeration as a bit field. Para obter mais informações, consulte a seção Membros não exclusivos e o atributo flags e o FlagsAttribute tópico.For more information, see the Non-Exclusive Members and the Flags Attribute section and the FlagsAttribute topic.

Neste tópico:In this topic:

Criando um tipo de enumeração Creating an enumeration type
Criando uma instância de um tipo de enumeração Instantiating an enumeration type
Práticas recomendadas de enumeração Enumeration best practices
Executando operações com enumerações Performing operations with enumerations
Executando conversõesPerforming conversions
Analisando valores de enumeraçãoParsing enumeration values
Formatando valores de enumeraçãoFormatting enumeration values
Iterando membros de enumeraçãoIterating enumeration members
Membros não exclusivos e o atributo flagsNon-exclusive members and the Flags attribute
Adicionando métodos de enumeraçãoAdding enumeration methods

Criando um tipo de enumeraçãoCreating an enumeration type

Linguagens de programação geralmente fornecem sintaxe para declarar uma enumeração que consiste em um conjunto de constantes nomeadas e seus valores.Programming languages typically provide syntax to declare an enumeration that consists of a set of named constants and their values. O exemplo a seguir ilustra a sintaxe usada C# pelo e Visual Basic para definir uma enumeração.The following example illustrates the syntax used by C# and Visual Basic to define an enumeration. Ele cria uma enumeração chamada ArrivalStatus que tem três membros: ArrivalStatus.Early, ArrivalStatus.OnTimee ArrivalStatus.Late.It creates an enumeration named ArrivalStatus that has three members: ArrivalStatus.Early, ArrivalStatus.OnTime, and ArrivalStatus.Late. Observe que em ambos os casos, a enumeração não herda explicitamente de Enum; a relação de herança é manipulada implicitamente pelo compilador.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

Aviso

Você nunca deve criar um tipo de enumeração cujo tipo subjacente seja não integral ou Char.You should never create an enumeration type whose underlying type is non-integral or Char. Embora você possa criar esse tipo de enumeração usando reflexão, as chamadas de método que usam o tipo resultante são não confiáveis e também podem gerar exceções adicionais.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.

Criando uma instância de um tipo de enumeraçãoInstantiating an enumeration type

Você pode criar uma instância de um tipo de enumeração da mesma forma que instancia qualquer outro tipo de valor: declarando uma variável e atribuindo uma das constantes da enumeração a ela.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. O exemplo a seguir instancia um ArrivalStatus cujo valor é 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)

Você também pode criar uma instância de um valor de enumeração das seguintes maneiras:You can also instantiate an enumeration value in the following ways:

  • Usando os recursos de uma linguagem de programação específica para converter (como C#em) ou converter (como em Visual Basic) um valor inteiro para um valor de enumeração.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. O exemplo a seguir cria ArrivalStatus um objeto cujo valor ArrivalStatus.Early é dessa maneira.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)
    
  • Chamando seu Construtor implícito sem parâmetros.By calling its implicit parameterless constructor. Como mostra o exemplo a seguir, nesse caso, o valor subjacente da instância de enumeração é 0.As the following example shows, in this case the underlying value of the enumeration instance is 0. No entanto, isso não é necessariamente o valor de uma constante válida na enumeração.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)
    
  • Chamando o Parse método ou TryParse para analisar uma cadeia de caracteres que contém o nome de uma constante na enumeração.By calling the Parse or TryParse method to parse a string that contains the name of a constant in the enumeration. Para obter mais informações, consulte a seção analisando valores de enumeração .For more information, see the Parsing Enumeration Values section.

  • Chamando o ToObject método para converter um valor integral em um tipo de enumeração.By calling the ToObject method to convert an integral value to an enumeration type. Para obter mais informações, consulte a seção realizando conversões .For more information, see the Performing Conversions section.

Práticas recomendadas de enumeraçãoEnumeration best practices

Recomendamos que você use as seguintes práticas recomendadas ao definir tipos de enumeração:We recommend that you use the following best practices when you define enumeration types:

  • Se você não tiver definido um membro de enumeração cujo valor é 0, considere a None criação de uma constante enumerada.If you have not defined an enumeration member whose value is 0, consider creating a None enumerated constant. Por padrão, a memória usada para a enumeração é inicializada como zero pelo Common Language Runtime.By default, the memory used for the enumeration is initialized to zero by the common language runtime. Consequentemente, se você não definir uma constante cujo valor é zero, a enumeração conterá um valor ilegal quando for criada.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • Se houver um caso padrão óbvio que seu aplicativo precisa representar, considere usar uma constante enumerada cujo valor seja zero para representá-lo.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. Se não houver nenhum caso padrão, considere usar uma constante enumerada cujo valor seja zero para especificar o caso que não é representado por qualquer uma das outras 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.

  • Não especifique constantes enumeradas que são reservadas para uso futuro.Do not specify enumerated constants that are reserved for future use.

  • Quando você define um método ou propriedade que usa uma constante enumerada como um valor, considere validar o valor.When you define a method or property that takes an enumerated constant as a value, consider validating the value. O motivo é que você pode converter um valor numérico para o tipo de enumeração, mesmo que esse valor numérico não seja definido na enumeração.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.

Práticas recomendadas adicionais para tipos de enumeração cujas constantes são campos de bits listados na seção de atributo de membros não exclusivos e de sinalizadores .Additional best practices for enumeration types whose constants are bit fields are listed in the Non-Exclusive Members and the Flags Attribute section.

Executando operações com enumeraçõesPerforming operations with enumerations

Você não pode definir novos métodos ao criar uma enumeração.You cannot define new methods when you are creating an enumeration. No entanto, um tipo de enumeração herda um conjunto completo de métodos estáticos Enum e de instância da classe.However, an enumeration type inherits a complete set of static and instance methods from the Enum class. As seções a seguir pesquisam a maioria desses métodos, além de vários outros métodos que são comumente usados ao trabalhar com valores de enumeração.The following sections survey most of these methods, in addition to several other methods that are commonly used when working with enumeration values.

Executando conversõesPerforming conversions

Você pode converter entre um membro de enumeração e seu tipo subjacente usando um operador cast ( C#in) ou Conversion (in 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. O exemplo a seguir usa os operadores Cast ou Conversion para executar conversões de um inteiro para um valor de enumeração e de um valor de enumeração para um inteiro.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)

A Enum classe também inclui um ToObject método que converte um valor de qualquer tipo integral para um valor de enumeração.The Enum class also includes a ToObject method that converts a value of any integral type to an enumeration value. O exemplo a seguir usa ToObject(Type, Int32) o método para converter Int32 um em ArrivalStatus um valor.The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. Observe que, como o ToObject retorna um valor do tipo Object, o uso de um operador de conversão ou multicast ainda pode ser necessário para converter o objeto para o tipo de enumeração.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)

Ao converter um inteiro em um valor de enumeração, é possível atribuir um valor que não seja realmente um membro da enumeração.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 evitar isso, você pode passar o inteiro para o IsDefined método antes de executar a conversão.To prevent this, you can pass the integer to the IsDefined method before performing the conversion. O exemplo a seguir usa esse método para determinar se os elementos em uma matriz de valores inteiros podem ser convertidos em ArrivalStatus valores.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

Embora a Enum classe forneça implementações IConvertible de interface explícitas da interface para converter de um valor de enumeração em um tipo integral, você deve Convert usar os métodos da classe, ToInt32como, para execute essas conversões.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. O exemplo a seguir ilustra como você pode usar GetUnderlyingType o método junto com Convert.ChangeType o método para converter um valor de enumeração em seu tipo subjacente.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. Observe que este exemplo não exige que o tipo subjacente da enumeração seja conhecido no momento da compilação.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

Analisando valores de enumeraçãoParsing enumeration values

Os Parse métodos TryParse e permitem que você converta a representação de cadeia de caracteres de um valor de enumeração para esse valor.The Parse and TryParse methods allow you to convert the string representation of an enumeration value to that value. A representação da cadeia de caracteres pode ser o nome ou o valor subjacente de uma constante de enumeração.The string representation can be either the name or the underlying value of an enumeration constant. Observe que os métodos de análise converterão com êxito as representações de cadeia de caracteres de números que não são membros de uma determinada enumeração se as cadeias de caracteres puderem ser convertidas em um valor de tipo subjacente da enumeração.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 isso, o IsDefined método pode ser chamado para garantir que o resultado do método de análise seja um valor de enumeração 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. O exemplo ilustra essa abordagem e demonstra chamadas para os Parse(Type, String) métodos e. 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. Observe que o método de análise não genérico retorna um objeto que você pode precisar converter (em C#) ou converter (em Visual Basic) para o tipo de enumeração apropriado.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

Formatando valores de enumeraçãoFormatting enumeration values

Você pode converter valores de enumeração em suas representações de cadeia de caracteres chamando Format o método estático, bem como as sobrecargas do método ToString de instância.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. Você pode usar uma cadeia de caracteres de formato para controlar a maneira exata em que um valor de enumeração é representado como uma cadeia de caracteres.You can use a format string to control the precise way in which an enumeration value is represented as a string. Para obter mais informações, consulte cadeias de formato de enumeração.For more information, see Enumeration Format Strings. O exemplo a seguir usa cada uma das cadeias de caracteres de formato de enumeração com suporte ("g" ou "g", "d" ou "d", "x" ou "x" e "f" ou "f") ArrivalStatus para converter um membro da enumeração para suas representações de cadeia de caracteres.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

Iterando membros de enumeraçãoIterating enumeration members

O Enum tipo não implementa a IEnumerable interface ou IEnumerable<T> , o que permitirá que você itere os membros de uma coleção usando foreach uma construção C#(in For Each ) ou (no 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. No entanto, você pode enumerar os membros de uma das duas maneiras.However, you can enumerate members in either of two ways.

  • Você pode chamar o GetNames método para recuperar uma matriz de cadeia de caracteres que contém os nomes dos membros da enumeração.You can call the GetNames method to retrieve a string array containing the names of the enumeration members. Em seguida, para cada elemento da matriz de cadeia de caracteres, você Parse pode chamar o método para converter a cadeia de caracteres em seu valor de enumeração equivalente.Next, for each element of the string array, you can call the Parse method to convert the string to its equivalent enumeration value. O exemplo a seguir ilustra esta abordagem.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)      
    
  • Você pode chamar o GetValues método para recuperar uma matriz que contém os valores subjacentes na enumeração.You can call the GetValues method to retrieve an array that contains the underlying values in the enumeration. Em seguida, para cada elemento da matriz, você pode chamar o ToObject método para converter o inteiro em seu valor de enumeração equivalente.Next, for each element of the array, you can call the ToObject method to convert the integer to its equivalent enumeration value. O exemplo a seguir ilustra esta abordagem.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)
    

Membros não exclusivos e o atributo flagsNon-exclusive members and the Flags attribute

Um uso comum de uma enumeração é para representar um conjunto de valores mutuamente exclusivos.One common use of an enumeration is to represent a set of mutually exclusive values. Por exemplo, uma ArrivalStatus instância pode ter um valor de Early, OnTimeou Late.For example, an ArrivalStatus instance can have a value of Early, OnTime, or Late. Não faz sentido que o valor de uma ArrivalStatus instância reflita mais de uma constante de enumeração.It makes no sense for the value of an ArrivalStatus instance to reflect more than one enumeration constant.

Em outros casos, no entanto, o valor de um objeto de enumeração pode incluir vários membros de enumeração, e cada membro representa um campo de bits no valor de enumeração.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. O FlagsAttribute atributo pode ser usado para indicar que a enumeração consiste em campos de bits.The FlagsAttribute attribute can be used to indicate that the enumeration consists of bit fields. Por exemplo, uma enumeração chamada Pets pode ser usada para indicar os tipos de animais de estimação em uma residência.For example, an enumeration named Pets might be used to indicate the kinds of pets in a household. Ele pode ser definido da seguinte maneira.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 Pets enumeração pode ser usada conforme mostrado no exemplo a seguir.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)      

As práticas recomendadas a seguir devem ser usadas durante a definição de uma enumeração FlagsAttribute de bits e a aplicação do atributo.The following best practices should be used when defining a bitwise enumeration and applying the FlagsAttribute attribute.

  • Use o FlagsAttribute atributo personalizado para uma enumeração somente se uma operação de bit (and, or, unexclusive ou) for executada em um 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 constantes de enumeração em potências de dois, ou seja, 1, 2, 4, 8 e assim por diante.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. Isso significa que os sinalizadores individuais em constantes de enumeração combinadas não se sobrepõem.This means the individual flags in combined enumeration constants do not overlap.

  • Considere a criação de uma constante enumerada para combinações de sinalizadores comumente usadas.Consider creating an enumerated constant for commonly used flag combinations. Por exemplo, se você tiver uma enumeração usada para operações de e/s de arquivo que contenham Read = 1 as Write = 2constantes enumeradas e, considere criar ReadWrite = Read OR Writea constante enumerada Read , Write que combina o e o flags.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. Além disso, a operação ou a bit de bits usada para combinar os sinalizadores pode ser considerada um conceito avançado em algumas circunstâncias que não devem ser necessárias para tarefas simples.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.

  • Tenha cuidado se você definir um número negativo como uma constante enumerada de sinalizador porque muitas posições de sinalizador podem ser definidas como 1, o que pode tornar seu código confuso e incentivar erros de codificação.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.

  • Uma maneira conveniente de testar se um sinalizador está definido em um valor numérico é chamar o método de HasFlag instância, conforme mostrado no exemplo a seguir.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.      
    

    É equivalente a executar uma operação AND bit a bit entre o valor numérico e a constante enumerada Flag, que define todos os bits no valor numérico como zero que não correspondem ao sinalizador e, em seguida, testando se o resultado dessa operação é igual ao sinalizar 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. Isso é ilustrado no exemplo a seguir.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 o nome da constante enumerada do sinalizador cujo valor é zero.Use None as the name of the flag enumerated constant whose value is zero. Você não pode usar None a constante enumerada em uma operação and bit a bit para testar um sinalizador porque o resultado é sempre zero.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. No entanto, você pode executar uma comparação lógica, não uma bit, entre o valor numérico None e a constante enumerada para determinar se todos os bits no valor numérico estão definidos.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. Isso é ilustrado no exemplo a seguir.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.      
    
  • Não defina um valor de enumeração exclusivamente para espelhar o estado da enumeração em si.Do not define an enumeration value solely to mirror the state of the enumeration itself. Por exemplo, não defina uma constante enumerada que simplesmente marque o final da enumeração.For example, do not define an enumerated constant that merely marks the end of the enumeration. Se você precisar determinar o último valor da enumeração, verifique esse valor explicitamente.If you need to determine the last value of the enumeration, check for that value explicitly. Além disso, você pode executar uma verificação de intervalo para a primeira e a última constante enumerada se todos os valores dentro do intervalo forem 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.

Adicionando métodos de enumeraçãoAdding enumeration methods

Como os tipos de enumeração são definidos por estruturas de linguagem enum ,C#como ( Enum ) e (Visual Basic), não é possível definir métodos personalizados para um tipo de enumeração Enum diferente daqueles métodos herdados da classe.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. No entanto, você pode usar métodos de extensão para adicionar funcionalidade a um tipo de enumeração específico.However, you can use extension methods to add functionality to a particular enumeration type.

No exemplo a seguir, a enumeração Grades representa as letras possíveis que um aluno pode receber em uma classe.In the following example, the Grades enumeration represents the possible letter grades that a student may receive in a class. Um método de extensão chamado Passing é adicionado ao tipo Grades de forma que cada instância desse tipo agora "sabe" se ele representa uma nota de aprovação ou não.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. A Extensions classe também contém uma variável estática de leitura/gravação que define a classificação mínima de passagem.The Extensions class also contains a static read-write variable that defines the minimum passing grade. O valor de retorno do Passing método de extensão reflete o valor atual dessa variável.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.

Construtores

Enum()

Inicializa uma nova instância da classe Enum.Initializes a new instance of the Enum class.

Métodos

CompareTo(Object)

Compara essa instância com um objeto especificado e retorna uma indicação dos valores relativos.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Object)

Retorna um valor que indica se essa instância é igual a um objeto especificado.Returns a value indicating whether this instance is equal to a specified object.

Format(Type, Object, String)

Converte o valor especificado de um tipo enumerado especificado em sua representação de cadeia de caracteres equivalente de acordo com o formato especificado.Converts the specified value of a specified enumerated type to its equivalent string representation according to the specified format.

GetHashCode()

Retorna o código hash para o valor dessa instância.Returns the hash code for the value of this instance.

GetName(Type, Object)

Recupera o nome da constante na enumeração especificada que tem o valor especificado.Retrieves the name of the constant in the specified enumeration that has the specified value.

GetNames(Type)

Recupera uma matriz de nomes de constantes em uma enumeração especificada.Retrieves an array of the names of the constants in a specified enumeration.

GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
GetTypeCode()

Retorna o código de tipo do tipo subjacente desse membro de enumeração.Returns the type code of the underlying type of this enumeration member.

GetUnderlyingType(Type)

Retorna o tipo subjacente da enumeração especificada.Returns the underlying type of the specified enumeration.

GetValues(Type)

Recupera uma matriz de valores de constantes em uma enumeração especificada.Retrieves an array of the values of the constants in a specified enumeration.

HasFlag(Enum)

Determina se um ou mais campos de bits são definidos na instância atual.Determines whether one or more bit fields are set in the current instance.

IsDefined(Type, Object)

Retorna um booliano informando se um determinado valor integral ou o seu nome como uma cadeia de caracteres existe em uma enumeração especificada.Returns a Boolean telling whether a given integral value, or its name as a string, exists in a specified enumeration.

MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
Parse(Type, String)

Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um 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)

Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Um parâmetro especifica se a operação não diferencia maiúsculas de minúsculas.A parameter specifies whether the operation is case-insensitive.

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

Converte o inteiro sem sinal de 8 bits especificado para um membro de enumeração.Converts the specified 8-bit unsigned integer to an enumeration member.

ToObject(Type, Int16)

Converte o inteiro com sinal de 16 bits especificado em um membro de enumeração.Converts the specified 16-bit signed integer to an enumeration member.

ToObject(Type, Int32)

Converte o inteiro com sinal de 32 bits especificado para um membro de enumeração.Converts the specified 32-bit signed integer to an enumeration member.

ToObject(Type, Int64)

Converte o inteiro com sinal de 64 bits especificado em um membro de enumeração.Converts the specified 64-bit signed integer to an enumeration member.

ToObject(Type, Object)

Converte o objeto especificado com um valor inteiro em um membro da enumeração.Converts the specified object with an integer value to an enumeration member.

ToObject(Type, SByte)

Converte o valor inteiro com sinal de 8 bits especificado em um membro de enumeração.Converts the specified 8-bit signed integer value to an enumeration member.

ToObject(Type, UInt16)

Converte o valor inteiro sem sinal de 16 bits especificado em um membro de enumeração.Converts the specified 16-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt32)

Converte o valor inteiro sem sinal de 32 bits especificado em um membro de enumeração.Converts the specified 32-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt64)

Converte o valor inteiro sem sinal de 64 bits especificado em um membro de enumeração.Converts the specified 64-bit unsigned integer value to an enumeration member.

ToString()

Converte o valor dessa instância na representação da cadeia de caracteres equivalente.Converts the value of this instance to its equivalent string representation.

ToString(IFormatProvider)

Essa sobrecarga de método é obsoleta; use ToString().This method overload is obsolete; use ToString().

ToString(String)

Converte o valor dessa instância para sua representação de cadeia de caracteres equivalente usando o formato especificado.Converts the value of this instance to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

Essa sobrecarga de método é obsoleta; use ToString(String).This method overload is obsolete; use ToString(String).

TryParse(Type, String, Boolean, Object)
TryParse(Type, String, Object)
TryParse<TEnum>(String, Boolean, TEnum)

Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Um parâmetro especifica se a operação diferencia maiúsculas de minúsculas.A parameter specifies whether the operation is case-sensitive. O valor de retorno indica se a conversão foi bem-sucedida.The return value indicates whether the conversion succeeded.

TryParse<TEnum>(String, TEnum)

Converte a representação da cadeia de caracteres do nome ou do valor numérico de uma ou mais constantes enumeradas em um objeto enumerado equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. O valor de retorno indica se a conversão foi bem-sucedida.The return value indicates whether the conversion succeeded.

Implantações explícitas de interface

IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Converte o valor atual em um valor booliano com base no tipo subjacente.Converts the current value to a Boolean value based on the underlying type.

IConvertible.ToByte(IFormatProvider)

Converte o valor atual em um inteiro sem sinal de 8 bits com base no tipo subjacente.Converts the current value to an 8-bit unsigned integer based on the underlying type.

IConvertible.ToChar(IFormatProvider)

Converte o valor atual em um caractere Unicode com base no tipo subjacente.Converts the current value to a Unicode character based on the underlying type.

IConvertible.ToDateTime(IFormatProvider)

Converte o valor atual em um DateTime com base no tipo subjacente.Converts the current value to a DateTime based on the underlying type.

IConvertible.ToDecimal(IFormatProvider)

Converte o valor atual em um Decimal com base no tipo subjacente.Converts the current value to a Decimal based on the underlying type.

IConvertible.ToDouble(IFormatProvider)

Converte o valor atual em um número de ponto flutuante de precisão dupla com base no tipo subjacente.Converts the current value to a double-precision floating point number based on the underlying type.

IConvertible.ToInt16(IFormatProvider)

Converte o valor atual em um inteiro com sinal de 16 bits com base no tipo subjacente.Converts the current value to a 16-bit signed integer based on the underlying type.

IConvertible.ToInt32(IFormatProvider)

Converte o valor atual em um inteiro com sinal de 32 bits com base no tipo subjacente.Converts the current value to a 32-bit signed integer based on the underlying type.

IConvertible.ToInt64(IFormatProvider)

Converte o valor atual em um inteiro com sinal de 64 bits com base no tipo subjacente.Converts the current value to a 64-bit signed integer based on the underlying type.

IConvertible.ToSByte(IFormatProvider)

Converte o valor atual em um inteiro com sinal de 8 bits com base no tipo subjacente.Converts the current value to an 8-bit signed integer based on the underlying type.

IConvertible.ToSingle(IFormatProvider)

Converte o valor atual em um número de ponto flutuante de precisão simples com base no tipo subjacente.Converts the current value to a single-precision floating-point number based on the underlying type.

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

Converte o valor atual em um tipo especificado com base no tipo subjacente.Converts the current value to a specified type based on the underlying type.

IConvertible.ToUInt16(IFormatProvider)

Converte o valor atual em um inteiro sem sinal de 16 bits com base no tipo subjacente.Converts the current value to a 16-bit unsigned integer based on the underlying type.

IConvertible.ToUInt32(IFormatProvider)

Converte o valor atual em um inteiro sem sinal de 32 bits com base no tipo subjacente.Converts the current value to a 32-bit unsigned integer based on the underlying type.

IConvertible.ToUInt64(IFormatProvider)

Converte o valor atual em um inteiro sem sinal de 64 bits com base no tipo subjacente.Converts the current value to a 64-bit unsigned integer based on the underlying type.

IFormattable.ToString(String, IFormatProvider)

Essa sobrecarga de método é obsoleta; use ToString(String).This method overload is obsolete; use ToString(String).

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.

Veja também