Enum Classe

Definizione

Si tratta della classe base per le enumerazioni.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
Ereditarietà
Derivato
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato l'utilizzo di un'enumerazione per rappresentare i valori denominati e un'altra enumerazione per rappresentare campi di bit denominati.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 

Commenti

Un'enumerazione è un set di costanti denominate il cui tipo sottostante è qualsiasi tipo integrale.An enumeration is a set of named constants whose underlying type is any integral type. Se non viene dichiarato in modo esplicito alcun tipo sottostante, viene utilizzato Int32.If no underlying type is explicitly declared, Int32 is used. Enum è la classe di base per tutte le enumerazioni nel .NET Framework.Enum is the base class for all enumerations in the .NET Framework. I tipi di enumerazione vengono definiti tramite la parola C# chiave enum in e il costrutto Enum...End Enum in Visual Basic.Enumeration types are defined by the enum keyword in C# and the Enum...End Enum construct in Visual Basic.

Enum fornisce metodi per confrontare le istanze di questa classe, convertendo il valore di un'istanza nella relativa rappresentazione di stringa, convertendo la rappresentazione di stringa di un numero in un'istanza di questa classe e creando un'istanza di un'enumerazione specificata. e value.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.

È anche possibile considerare un'enumerazione come un campo di bit.You can also treat an enumeration as a bit field. Per ulteriori informazioni, vedere la sezione membri non esclusivi e attributo Flags e l'argomento FlagsAttribute.For more information, see the Non-Exclusive Members and the Flags Attribute section and the FlagsAttribute topic.

In questo argomentoIn this topic:

Creazione di un tipo di enumerazione Creating an enumeration type
Creazione di un'istanza di un tipo di enumerazione Instantiating an enumeration type
Procedure consigliate per l'enumerazione Enumeration best practices
Esecuzione di operazioni con enumerazioni Performing operations with enumerations
Esecuzione delle conversioniPerforming conversions
Analisi dei valori di enumerazioneParsing enumeration values
Formattazione dei valori di enumerazioneFormatting enumeration values
Iterazione dei membri di enumerazioneIterating enumeration members
Membri non esclusivi e attributo FlagsNon-exclusive members and the Flags attribute
Aggiunta di metodi di enumerazioneAdding enumeration methods

Creazione di un tipo di enumerazioneCreating an enumeration type

I linguaggi di programmazione forniscono in genere la sintassi per dichiarare un'enumerazione costituita da un set di costanti denominate e dai relativi valori.Programming languages typically provide syntax to declare an enumeration that consists of a set of named constants and their values. Nell'esempio seguente viene illustrata la sintassi utilizzata C# da e Visual Basic per definire un'enumerazione.The following example illustrates the syntax used by C# and Visual Basic to define an enumeration. Viene creata un'enumerazione denominata ArrivalStatus con tre membri: ArrivalStatus.Early, ArrivalStatus.OnTimee ArrivalStatus.Late.It creates an enumeration named ArrivalStatus that has three members: ArrivalStatus.Early, ArrivalStatus.OnTime, and ArrivalStatus.Late. Si noti che in entrambi i casi l'enumerazione non eredita in modo esplicito da Enum; la relazione di ereditarietà viene gestita in modo implicito dal compilatore.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

Avviso

Non creare mai un tipo di enumerazione il cui tipo sottostante sia non integrale o Char.You should never create an enumeration type whose underlying type is non-integral or Char. Sebbene sia possibile creare questo tipo di enumerazione usando la reflection, le chiamate al metodo che usano il tipo risultante sono inaffidabili e possono anche generare eccezioni aggiuntive.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.

Creazione di un'istanza di un tipo di enumerazioneInstantiating an enumeration type

È possibile creare un'istanza di un tipo di enumerazione così come si crea un'istanza di qualsiasi altro tipo di valore: dichiarando una variabile e assegnando una delle costanti dell'enumerazione.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. Nell'esempio seguente viene creata un'istanza di un ArrivalStatus il cui valore è 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)

È anche possibile creare un'istanza di un valore di enumerazione nei modi seguenti:You can also instantiate an enumeration value in the following ways:

  • Utilizzando le funzionalità specifiche del linguaggio di programmazione per eseguire il cast ( C#come in) o convertire (come in Visual Basic) un valore integer in un valore di enumerazione.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. Nell'esempio seguente viene creato un oggetto ArrivalStatus il cui valore viene ArrivalStatus.Early in questo modo.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)
    
  • Chiamando il relativo costruttore senza parametri implicito.By calling its implicit parameterless constructor. Come illustrato nell'esempio seguente, in questo caso il valore sottostante dell'istanza di enumerazione è 0.As the following example shows, in this case the underlying value of the enumeration instance is 0. Tuttavia, non si tratta necessariamente del valore di una costante valida nell'enumerazione.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)
    
  • Chiamando il metodo Parse o TryParse per analizzare una stringa che contiene il nome di una costante nell'enumerazione.By calling the Parse or TryParse method to parse a string that contains the name of a constant in the enumeration. Per ulteriori informazioni, vedere la sezione analisi dei valori di enumerazione .For more information, see the Parsing Enumeration Values section.

  • Chiamando il metodo ToObject per convertire un valore integrale in un tipo di enumerazione.By calling the ToObject method to convert an integral value to an enumeration type. Per ulteriori informazioni, vedere la sezione esecuzione delle conversioni .For more information, see the Performing Conversions section.

Procedure consigliate per l'enumerazioneEnumeration best practices

Quando si definiscono i tipi di enumerazione, è consigliabile utilizzare le seguenti procedure consigliate:We recommend that you use the following best practices when you define enumeration types:

  • Se non è stato definito un membro di enumerazione il cui valore è 0, provare a creare una costante enumerata None.If you have not defined an enumeration member whose value is 0, consider creating a None enumerated constant. Per impostazione predefinita, la memoria usata per l'enumerazione viene inizializzata su zero dal Common Language Runtime.By default, the memory used for the enumeration is initialized to zero by the common language runtime. Di conseguenza, se non si definisce una costante il cui valore è zero, l'enumerazione conterrà un valore non valido al momento della creazione.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • Se è presente un caso predefinito ovvio che l'applicazione deve rappresentare, provare a usare una costante enumerata il cui valore è zero per rappresentarlo.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 non esiste un case predefinito, è consigliabile utilizzare una costante enumerata il cui valore è zero per specificare il case non rappresentato da nessuna delle altre costanti enumerate.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.

  • Non specificare costanti enumerate riservate per un utilizzo futuro.Do not specify enumerated constants that are reserved for future use.

  • Quando si definisce un metodo o una proprietà che accetta una costante enumerata come valore, provare a convalidare il valore.When you define a method or property that takes an enumerated constant as a value, consider validating the value. Il motivo è che è possibile eseguire il cast di un valore numerico al tipo di enumerazione anche se tale valore numerico non è definito nell'enumerazione.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.

Altre procedure consigliate per i tipi di enumerazione le cui costanti sono i campi di bit sono elencate nella sezione membri non esclusivi e attributo Flags .Additional best practices for enumeration types whose constants are bit fields are listed in the Non-Exclusive Members and the Flags Attribute section.

Esecuzione di operazioni con enumerazioniPerforming operations with enumerations

Non è possibile definire nuovi metodi quando si crea un'enumerazione.You cannot define new methods when you are creating an enumeration. Tuttavia, un tipo di enumerazione eredita un set completo di metodi statici e di istanza dalla classe Enum.However, an enumeration type inherits a complete set of static and instance methods from the Enum class. Le sezioni seguenti esaminano la maggior parte di questi metodi, oltre a diversi altri metodi comunemente usati quando si utilizzano valori di enumerazione.The following sections survey most of these methods, in addition to several other methods that are commonly used when working with enumeration values.

Esecuzione delle conversioniPerforming conversions

È possibile eseguire la conversione tra un membro di enumerazione e il tipo sottostante usando un operatore C#di cast (in) o di conversione (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. Nell'esempio seguente vengono utilizzati gli operatori di cast o conversione per eseguire le conversioni da un Integer a un valore di enumerazione e da un valore di enumerazione a un Integer.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 classe Enum include inoltre un metodo ToObject che converte un valore di qualsiasi tipo integrale in un valore di enumerazione.The Enum class also includes a ToObject method that converts a value of any integral type to an enumeration value. Nell'esempio seguente viene usato il metodo ToObject(Type, Int32) per convertire un Int32 in un valore di ArrivalStatus.The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. Si noti che, poiché il ToObject restituisce un valore di tipo Object, l'uso di un operatore di cast o di conversione può ancora essere necessario per eseguire il cast dell'oggetto al tipo di enumerazione.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)

Quando si converte un numero intero in un valore di enumerazione, è possibile assegnare un valore che non è effettivamente un membro dell'enumerazione.When converting an integer to an enumeration value, it is possible to assign a value that is not actually a member of the enumeration. Per evitare questo problema, è possibile passare il valore integer al metodo IsDefined prima di eseguire la conversione.To prevent this, you can pass the integer to the IsDefined method before performing the conversion. Nell'esempio seguente viene usato questo metodo per determinare se gli elementi in una matrice di valori integer possono essere convertiti in valori 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

Sebbene la classe Enum fornisca implementazioni esplicite dell'interfaccia IConvertible per la conversione da un valore di enumerazione a un tipo integrale, è consigliabile usare i metodi della classe Convert, ad esempio ToInt32, per eseguire queste conversioni.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. Nell'esempio seguente viene illustrato come è possibile utilizzare il metodo GetUnderlyingType insieme al metodo Convert.ChangeType per convertire un valore di enumerazione nel tipo sottostante.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. Si noti che questo esempio non richiede che il tipo sottostante dell'enumerazione sia noto in fase di compilazione.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

Analisi dei valori di enumerazioneParsing enumeration values

I metodi Parse e TryParse consentono di convertire la rappresentazione di stringa di un valore di enumerazione in tale valore.The Parse and TryParse methods allow you to convert the string representation of an enumeration value to that value. La rappresentazione di stringa può essere il nome o il valore sottostante di una costante di enumerazione.The string representation can be either the name or the underlying value of an enumeration constant. Si noti che i metodi di analisi consentono di convertire correttamente le rappresentazioni di stringa dei numeri che non sono membri di una particolare enumerazione se le stringhe possono essere convertite in un valore del tipo sottostante dell'enumerazione.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. Per evitare questo problema, è possibile chiamare il metodo IsDefined per assicurarsi che il risultato del metodo di analisi sia un valore di enumerazione valido.To prevent this, the IsDefined method can be called to ensure that the result of the parsing method is a valid enumeration value. Questo approccio viene illustrato nell'esempio e vengono illustrate le chiamate ai metodi Parse(Type, String) 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. Si noti che il metodo di analisi non generico restituisce un oggetto di cui potrebbe essere necessario eseguire il cast C#(in) o convertire (in Visual Basic) nel tipo di enumerazione appropriato.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

Formattazione dei valori di enumerazioneFormatting enumeration values

È possibile convertire i valori di enumerazione nelle rappresentazioni di stringa chiamando il metodo statico Format, nonché gli overload del metodo dell'istanza ToString.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. È possibile usare una stringa di formato per controllare il modo preciso in cui un valore di enumerazione viene rappresentato come stringa.You can use a format string to control the precise way in which an enumeration value is represented as a string. Per altre informazioni, vedere stringhe di formato di enumerazione.For more information, see Enumeration Format Strings. Nell'esempio seguente vengono usate le stringhe di formato di enumerazione supportate ("G" o "g", "D" o "d", "X" o "x" e "F" o "f") per convertire un membro dell'enumerazione ArrivalStatus nelle rappresentazioni di stringa.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

Iterazione dei membri di enumerazioneIterating enumeration members

Il tipo di Enum non implementa l'interfaccia IEnumerable o IEnumerable<T>, che consente di scorrere i membri di una raccolta usando un costrutto foreach (in C#) o For Each (in 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. È tuttavia possibile enumerare i membri in uno dei due modi.However, you can enumerate members in either of two ways.

  • È possibile chiamare il metodo GetNames per recuperare una matrice di stringhe contenente i nomi dei membri dell'enumerazione.You can call the GetNames method to retrieve a string array containing the names of the enumeration members. Per ogni elemento della matrice di stringhe, è quindi possibile chiamare il metodo Parse per convertire la stringa nel valore di enumerazione equivalente.Next, for each element of the string array, you can call the Parse method to convert the string to its equivalent enumeration value. Questo approccio viene illustrato nell'esempio seguente: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)      
    
  • È possibile chiamare il metodo GetValues per recuperare una matrice che contiene i valori sottostanti nell'enumerazione.You can call the GetValues method to retrieve an array that contains the underlying values in the enumeration. Quindi, per ogni elemento della matrice, è possibile chiamare il metodo ToObject per convertire l'intero nel valore di enumerazione equivalente.Next, for each element of the array, you can call the ToObject method to convert the integer to its equivalent enumeration value. Questo approccio viene illustrato nell'esempio seguente: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)
    

Membri non esclusivi e attributo FlagsNon-exclusive members and the Flags attribute

Un utilizzo comune di un'enumerazione consiste nel rappresentare un set di valori che si escludono a vicenda.One common use of an enumeration is to represent a set of mutually exclusive values. Ad esempio, un'istanza di ArrivalStatus può avere un valore di Early, OnTimeo Late.For example, an ArrivalStatus instance can have a value of Early, OnTime, or Late. Non è opportuno che il valore di un'istanza di ArrivalStatus rifletta più di una costante di enumerazione.It makes no sense for the value of an ArrivalStatus instance to reflect more than one enumeration constant.

In altri casi, tuttavia, il valore di un oggetto di enumerazione può includere più membri di enumerazione e ogni membro rappresenta un campo di bit nel valore di enumerazione.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. È possibile utilizzare l'attributo FlagsAttribute per indicare che l'enumerazione è costituita da campi di bit.The FlagsAttribute attribute can be used to indicate that the enumeration consists of bit fields. Ad esempio, è possibile usare un'enumerazione denominata Pets per indicare i tipi di animali domestici in una famiglia.For example, an enumeration named Pets might be used to indicate the kinds of pets in a household. Può essere definito come segue.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

L'enumerazione Pets può quindi essere usata come illustrato nell'esempio seguente.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)      

Quando si definisce un'enumerazione bit per bit e si applica l'attributo FlagsAttribute, è consigliabile utilizzare le procedure consigliate seguenti.The following best practices should be used when defining a bitwise enumeration and applying the FlagsAttribute attribute.

  • Utilizzare l'FlagsAttribute attributo personalizzato per un'enumerazione solo se è necessario eseguire un'operazione bit per bit (AND, OR, EXCLUSIVe o) su un valore numerico.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.

  • Definire le costanti di enumerazione in potenze di due, ovvero 1, 2, 4, 8 e così via.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. Ciò significa che i singoli flag nelle costanti di enumerazione combinate non si sovrappongono.This means the individual flags in combined enumeration constants do not overlap.

  • Prendere in considerazione la creazione di una costante enumerata per le combinazioni di flag usate di frequente.Consider creating an enumerated constant for commonly used flag combinations. Se, ad esempio, si dispone di un'enumerazione utilizzata per le operazioni di I/O di file che contiene le costanti enumerate Read = 1 e Write = 2, provare a creare la costante enumerata ReadWrite = Read OR Write, che combina i flag di Read e di 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. Inoltre, l'operazione OR bit per bit utilizzata per combinare i flag potrebbe essere considerata un concetto avanzato in alcune circostanze che non dovrebbe essere necessario per le attività semplici.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.

  • Prestare attenzione se si definisce un numero negativo come costante enumerata flag, perché molte posizioni dei flag potrebbero essere impostate su 1, il che potrebbe rendere il codice confuso e incoraggiare gli errori di codifica.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.

  • Un modo pratico per verificare se un flag è impostato in un valore numerico consiste nel chiamare l'istanza HasFlag metodo, come illustrato nell'esempio seguente.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.      
    

    Equivale a eseguire un'operazione con AND bit per bit tra il valore numerico e la costante enumerata flag, che imposta tutti i bit del valore numerico su zero che non corrispondono al flag e quindi verifica se il risultato dell'operazione è uguale a flag (costante enumerata).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. Questa procedura è illustrata nell'esempio riportato di seguito.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.      
    
  • Usare None come nome della costante enumerata flag il cui valore è zero.Use None as the name of the flag enumerated constant whose value is zero. Non è possibile usare la costante enumerata None in un'operazione AND bit per bit per verificare un flag perché il risultato è 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. Tuttavia, è possibile eseguire un confronto logico, non bit per bit, tra il valore numerico e la costante enumerata None per determinare se sono impostati bit nel valore numerico.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. Questa procedura è illustrata nell'esempio riportato di seguito.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.      
    
  • Non definire un valore di enumerazione esclusivamente per eseguire il mirroring dello stato dell'enumerazione stessa.Do not define an enumeration value solely to mirror the state of the enumeration itself. Ad esempio, non definire una costante enumerata che contrassegna solo la fine dell'enumerazione.For example, do not define an enumerated constant that merely marks the end of the enumeration. Se è necessario determinare l'ultimo valore dell'enumerazione, verificare in modo esplicito tale valore.If you need to determine the last value of the enumeration, check for that value explicitly. Inoltre, è possibile eseguire un controllo dell'intervallo per la prima e l'ultima costante enumerata se tutti i valori compresi nell'intervallo sono validi.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

Aggiunta di metodi di enumerazioneAdding enumeration methods

Poiché i tipi di enumerazione sono definiti dalle strutture di linguaggio, adC#esempio enum () e Enum (Visual Basic), non è possibile definire metodi personalizzati per un tipo di enumerazione diverso da quelli ereditati dalla classe 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. Tuttavia, è possibile usare i metodi di estensione per aggiungere funzionalità a un particolare tipo di enumerazione.However, you can use extension methods to add functionality to a particular enumeration type.

Nell'esempio seguente, l'enumerazione Grades rappresenta il voto che uno studente potrebbe ricevere in un corso.In the following example, the Grades enumeration represents the possible letter grades that a student may receive in a class. Il metodo di estensione denominato Passing viene aggiunto al tipo Grades in modo che ogni istanza di tale tipo ora "sa" se rappresenta un voto sufficiente oppure 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 classe Extensions contiene anche una variabile di lettura/scrittura statica che definisce il livello minimo passato.The Extensions class also contains a static read-write variable that defines the minimum passing grade. Il valore restituito del metodo di estensione Passing riflette il valore corrente della variabile.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.

Costruttori

Enum()

Inizializza una nuova istanza della classe Enum.Initializes a new instance of the Enum class.

Metodi

CompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un'indicazione dei valori relativi.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.Returns a value indicating whether this instance is equal to a specified object.

Format(Type, Object, String)

Converte il valore specificato di un determinato tipo enumerato nella rappresentazione di stringa equivalente, secondo il formato specificato.Converts the specified value of a specified enumerated type to its equivalent string representation according to the specified format.

GetHashCode()

Viene restituito il codice hash per il valore dell'istanza.Returns the hash code for the value of this instance.

GetName(Type, Object)

Restituisce il nome della costante nell'enumerazione del valore specificato.Retrieves the name of the constant in the specified enumeration that has the specified value.

GetNames(Type)

Restituisce una matrice dei nomi delle costanti in una enumerazione specificata.Retrieves an array of the names of the constants in a specified enumeration.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
GetTypeCode()

Restituisce il codice del tipo sottostante di questo membro di enumerazione.Returns the type code of the underlying type of this enumeration member.

GetUnderlyingType(Type)

Restituisce il tipo sottostante dell'enumerazione specificata.Returns the underlying type of the specified enumeration.

GetValues(Type)

Restituisce una matrice dei valori delle costanti in una enumerazione specificata.Retrieves an array of the values of the constants in a specified enumeration.

HasFlag(Enum)

Determina se uno o più campi di bit vengono impostati nell'istanza corrente.Determines whether one or more bit fields are set in the current instance.

IsDefined(Type, Object)

Restituisce un valore booleano se in un'enumerazione specificata esiste un determinato valore integrale o il relativo nome sotto forma di stringa.Returns a Boolean telling whether a given integral value, or its name as a string, exists in a specified enumeration.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
Parse(Type, String)

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato 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 la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.A parameter specifies whether the operation is case-insensitive.

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

Converte l'intero senza segno a 8 bit specificato in un membro di enumerazione.Converts the specified 8-bit unsigned integer to an enumeration member.

ToObject(Type, Int16)

Converte l'intero con segno a 16 bit specificato in un membro di enumerazione.Converts the specified 16-bit signed integer to an enumeration member.

ToObject(Type, Int32)

Converte l'intero con segno a 32 bit specificato in un membro di enumerazione.Converts the specified 32-bit signed integer to an enumeration member.

ToObject(Type, Int64)

Converte l'intero con segno a 64 bit specificato in un membro di enumerazione.Converts the specified 64-bit signed integer to an enumeration member.

ToObject(Type, Object)

Converte l'oggetto specificato con un valore intero in un membro di enumerazione.Converts the specified object with an integer value to an enumeration member.

ToObject(Type, SByte)

Converte il valore dell'intero con segno a 8 bit specificato in un membro di enumerazione.Converts the specified 8-bit signed integer value to an enumeration member.

ToObject(Type, UInt16)

Converte il valore dell'intero senza segno a 16 bit specificato in un membro di enumerazione.Converts the specified 16-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt32)

Converte il valore dell'intero senza segno a 32 bit specificato in un membro di enumerazione.Converts the specified 32-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt64)

Converte il valore dell'intero senza segno a 64 bit specificato in un membro di enumerazione.Converts the specified 64-bit unsigned integer value to an enumeration member.

ToString()

Converte il valore dell'istanza corrente nell'equivalente rappresentazione di stringa.Converts the value of this instance to its equivalent string representation.

ToString(IFormatProvider)

L'overload di questo metodo è obsoleto; usare ToString().This method overload is obsolete; use ToString().

ToString(String)

Converte il valore dell'istanza corrente nella rappresentazione di stringa equivalente, usando il formato specificato.Converts the value of this instance to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

L'overload di questo metodo è obsoleto; usare ToString(String).This method overload is obsolete; use ToString(String).

TryParse(Type, String, Boolean, Object)

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato 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)

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato 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)

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Un parametro specifica se l'operazione verrà eseguita con distinzione tra maiuscole e minuscole.A parameter specifies whether the operation is case-sensitive. Il valore restituito indica se la conversione è riuscita.The return value indicates whether the conversion succeeded.

TryParse<TEnum>(String, TEnum)

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Il valore restituito indica se la conversione è riuscita.The return value indicates whether the conversion succeeded.

Implementazioni dell'interfaccia esplicita

IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Converte il valore corrente in un valore booleano basato sul tipo sottostante.Converts the current value to a Boolean value based on the underlying type.

IConvertible.ToByte(IFormatProvider)

Converte il valore corrente in un intero senza segno a 8 bit basato sul tipo sottostante.Converts the current value to an 8-bit unsigned integer based on the underlying type.

IConvertible.ToChar(IFormatProvider)

Converte il valore corrente in un carattere Unicode basato sul tipo sottostante.Converts the current value to a Unicode character based on the underlying type.

IConvertible.ToDateTime(IFormatProvider)

Converte il valore corrente in un oggetto DateTime basato sul tipo sottostante.Converts the current value to a DateTime based on the underlying type.

IConvertible.ToDecimal(IFormatProvider)

Converte il valore corrente in un oggetto Decimal basato sul tipo sottostante.Converts the current value to a Decimal based on the underlying type.

IConvertible.ToDouble(IFormatProvider)

Converte il valore corrente in un numero a virgola mobile e precisione doppia basato sul tipo sottostante.Converts the current value to a double-precision floating point number based on the underlying type.

IConvertible.ToInt16(IFormatProvider)

Converte il valore corrente in un intero con segno a 16 bit basato sul tipo sottostante.Converts the current value to a 16-bit signed integer based on the underlying type.

IConvertible.ToInt32(IFormatProvider)

Converte il valore corrente in un intero con segno a 32 bit basato sul tipo sottostante.Converts the current value to a 32-bit signed integer based on the underlying type.

IConvertible.ToInt64(IFormatProvider)

Converte il valore corrente in un intero con segno a 64 bit basato sul tipo sottostante.Converts the current value to a 64-bit signed integer based on the underlying type.

IConvertible.ToSByte(IFormatProvider)

Converte il valore corrente in un intero con segno a 8 bit basato sul tipo sottostante.Converts the current value to an 8-bit signed integer based on the underlying type.

IConvertible.ToSingle(IFormatProvider)

Converte il valore corrente in un numero a virgola mobile e con precisione singola in base al tipo sottostante.Converts the current value to a single-precision floating-point number based on the underlying type.

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

Converte il valore corrente in un tipo specificato basato sul tipo sottostante.Converts the current value to a specified type based on the underlying type.

IConvertible.ToUInt16(IFormatProvider)

Converte il valore corrente in un intero senza segno a 16 bit basato sul tipo sottostante.Converts the current value to a 16-bit unsigned integer based on the underlying type.

IConvertible.ToUInt32(IFormatProvider)

Converte il valore corrente in un intero senza segno a 32 bit basato sul tipo sottostante.Converts the current value to a 32-bit unsigned integer based on the underlying type.

IConvertible.ToUInt64(IFormatProvider)

Converte il valore corrente in un intero senza segno a 64 bit basato sul tipo sottostante.Converts the current value to a 64-bit unsigned integer based on the underlying type.

IFormattable.ToString(String, IFormatProvider)

L'overload di questo metodo è obsoleto; usare ToString(String).This method overload is obsolete; use ToString(String).

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche