Enum Třída

Definice

Poskytuje základní třídu pro výčty.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
Dědičnost
Odvozené
Atributy
Implementuje

Příklady

Následující příklad ukazuje použití výčtu k reprezentaci pojmenovaných hodnot a dalšího výčtu pro reprezentaci pojmenovaných bitových polí.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 

Poznámky

Výčet je sada pojmenovaných konstant, jejichž základní typ je libovolný integrální typ.An enumeration is a set of named constants whose underlying type is any integral type. Pokud není explicitně deklarován žádný nadřízený typ, je použita Int32.If no underlying type is explicitly declared, Int32 is used. Enum je základní třídou pro všechny výčty v .NET Framework.Enum is the base class for all enumerations in the .NET Framework. Výčtové typy jsou definovány pomocí klíčového slova C# enum v a Enum...End Enum konstrukce v Visual Basic.Enumeration types are defined by the enum keyword in C# and the Enum...End Enum construct in Visual Basic.

Enum poskytuje metody pro porovnávání instancí této třídy, konverzi hodnoty instance na její řetězcové vyjádření, převod řetězcové reprezentace čísla na instanci této třídy a vytvoření instance zadaného výčtu a hodnoty.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.

Výčet můžete také považovat za bitové pole.You can also treat an enumeration as a bit field. Další informace naleznete v části nevýhradní členové a atributu flags a v tématu FlagsAttribute.For more information, see the Non-Exclusive Members and the Flags Attribute section and the FlagsAttribute topic.

V tomto tématu:In this topic:

Vytvoření typu výčtu Creating an enumeration type
Vytvoření instance typu výčtu Instantiating an enumeration type
Doporučené postupy pro výčetEnumeration best practices
Provádění operací s výčty Performing operations with enumerations
Provádění převodůPerforming conversions
Analýza hodnot výčtuParsing enumeration values
Formátování hodnot výčtuFormatting enumeration values
Iterace členů výčtuIterating enumeration members
Nevýhradní členové a atribut FlagsNon-exclusive members and the Flags attribute
Přidání metod výčtuAdding enumeration methods

Vytvoření typu výčtuCreating an enumeration type

Programovací jazyky obvykle poskytují syntaxi k deklaraci výčtu, který se skládá ze sady pojmenovaných konstant a jejich hodnot.Programming languages typically provide syntax to declare an enumeration that consists of a set of named constants and their values. Následující příklad ilustruje syntaxi použitou C# a Visual Basic k definování výčtu.The following example illustrates the syntax used by C# and Visual Basic to define an enumeration. Vytvoří výčet s názvem ArrivalStatus, který má tři členy: ArrivalStatus.Early, ArrivalStatus.OnTimea ArrivalStatus.Late.It creates an enumeration named ArrivalStatus that has three members: ArrivalStatus.Early, ArrivalStatus.OnTime, and ArrivalStatus.Late. Všimněte si, že v obou případech výčet explicitně nedědí z Enum; vztah dědičnosti se implicitně zpracovává kompilátorem.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

Varování

Nikdy byste neměli vytvořit typ výčtu, jehož základní typ je neintegrální nebo Char.You should never create an enumeration type whose underlying type is non-integral or Char. I když můžete vytvořit takový typ výčtu pomocí reflexe, volání metody, které používají výsledný typ, jsou nespolehlivá a mohou také vyvolat další výjimky.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.

Vytvoření instance typu výčtuInstantiating an enumeration type

Můžete vytvořit instanci typu výčtu stejně jako při vytváření instance jiného typu hodnoty: deklarováním proměnné a přiřazením jedné z konstant výčtu.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. Následující příklad vytvoří instanci ArrivalStatus, jehož hodnota je 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)

Můžete také vytvořit instanci hodnoty výčtu následujícími způsoby:You can also instantiate an enumeration value in the following ways:

  • Použitím funkcí konkrétního programovacího jazyka k přetypování (jako v C#rámci) nebo převodu (jako v Visual Basic) celočíselné hodnoty na hodnotu výčtu.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. Následující příklad vytvoří objekt ArrivalStatus, jehož hodnota je ArrivalStatus.Early tímto způsobem.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)
    
  • Voláním jeho implicitního konstruktoru bez parametrů.By calling its implicit parameterless constructor. Jak ukazuje následující příklad, v tomto případě je základní hodnota instance výčtu 0.As the following example shows, in this case the underlying value of the enumeration instance is 0. To ale nutně není hodnota platné konstanty ve výčtu.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)
    
  • Voláním metody Parse nebo TryParse k analýze řetězce, který obsahuje název konstanty ve výčtu.By calling the Parse or TryParse method to parse a string that contains the name of a constant in the enumeration. Další informace najdete v části Analýza hodnot výčtu .For more information, see the Parsing Enumeration Values section.

  • Voláním metody ToObject pro převod integrální hodnoty na typ výčtu.By calling the ToObject method to convert an integral value to an enumeration type. Další informace najdete v části provádění převodů .For more information, see the Performing Conversions section.

Osvědčené postupy pro výčetEnumeration best practices

Při definování typů výčtu doporučujeme použít následující osvědčené postupy:We recommend that you use the following best practices when you define enumeration types:

  • Pokud jste nedefinovali člen výčtu, jehož hodnota je 0, zvažte vytvoření výčtové konstanty None.If you have not defined an enumeration member whose value is 0, consider creating a None enumerated constant. Ve výchozím nastavení je paměť použitá pro výčet inicializována na nulu modulem CLR (Common Language Runtime).By default, the memory used for the enumeration is initialized to zero by the common language runtime. V důsledku toho, pokud nedefinujete konstantu, jejíž hodnota je nula, výčet bude při vytvoření obsahovat neplatnou hodnotu.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • Pokud existuje zjevně výchozí případ, který musí vaše aplikace reprezentovat, zvažte použití výčtu konstanty, jejíž hodnota je nula, aby ji představovala.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. Pokud není žádný výchozí případ, zvažte použití výčtu konstanty, jejíž hodnota je nula pro určení případu, který není reprezentován žádnou z dalších výčtových konstant.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.

  • Nezadávejte výčtové konstanty, které jsou vyhrazené pro budoucí použití.Do not specify enumerated constants that are reserved for future use.

  • Pokud definujete metodu nebo vlastnost, která přebírá výčtovou konstantu jako hodnotu, zvažte ověření hodnoty.When you define a method or property that takes an enumerated constant as a value, consider validating the value. Důvodem je, že můžete přetypovat číselnou hodnotu na typ výčtu i v případě, že číselná hodnota není definována ve výčtu.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.

Další osvědčené postupy pro výčtové typy, jejichž konstanty jsou bitové pole, jsou uvedeny v části neexkluzivní členové a atribut Flags .Additional best practices for enumeration types whose constants are bit fields are listed in the Non-Exclusive Members and the Flags Attribute section.

Provádění operací s výčtyPerforming operations with enumerations

Při vytváření výčtu nelze definovat nové metody.You cannot define new methods when you are creating an enumeration. Nicméně typ výčtu dědí kompletní sadu statických a instančních metod z třídy Enum.However, an enumeration type inherits a complete set of static and instance methods from the Enum class. Následující části procházejí většinu těchto metod, kromě několika dalších metod, které jsou obvykle používány při práci s hodnotami výčtu.The following sections survey most of these methods, in addition to several other methods that are commonly used when working with enumeration values.

Provádění převodůPerforming conversions

Můžete převést mezi členem výčtu a jeho podkladovým typem pomocí operátoru přetypování ( C#in) nebo konverze (v 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. Následující příklad používá přetypování nebo operátory převodu k provádění převodů z celého čísla na hodnotu výčtu a z hodnoty výčtu na celé číslo.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)

Třída Enum obsahuje také metodu ToObject, která převede hodnotu jakéhokoli integrálního typu na hodnotu výčtu.The Enum class also includes a ToObject method that converts a value of any integral type to an enumeration value. Následující příklad používá metodu ToObject(Type, Int32) k převedení Int32 na ArrivalStatus hodnotu.The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. Všimněte si, že protože ToObject vrátí hodnotu typu Object, použití operátoru přetypování nebo konverze může být stále nutné pro přetypování objektu na typ výčtu.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)

Při převodu celého čísla na hodnotu výčtu je možné přiřadit hodnotu, která není ve skutečnosti členem výčtu.When converting an integer to an enumeration value, it is possible to assign a value that is not actually a member of the enumeration. Chcete-li tomu zabránit, můžete před provedením převodu předat celé číslo do metody IsDefined.To prevent this, you can pass the integer to the IsDefined method before performing the conversion. Následující příklad používá tuto metodu k určení, zda prvky v poli celočíselných hodnot lze převést na ArrivalStatus hodnoty.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

I když třída Enum poskytuje explicitní implementaci rozhraní IConvertible rozhraní pro převod z hodnoty výčtu na celočíselný typ, měli byste použít metody třídy Convert, jako je například ToInt32, k provedení těchto převodů.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. Následující příklad ukazuje, jak lze použít metodu GetUnderlyingType společně s metodou Convert.ChangeType pro převod hodnoty výčtu na jeho nadřízený typ.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. Všimněte si, že tento příklad nevyžaduje základní typ výčtu, který by měl být známý v době kompilace.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

Analýza hodnot výčtuParsing enumeration values

Metody Parse a TryParse umožňují převést řetězcové vyjádření hodnoty výčtu na tuto hodnotu.The Parse and TryParse methods allow you to convert the string representation of an enumeration value to that value. Řetězcová reprezentace může být buď název, nebo podkladová hodnota konstanty výčtu.The string representation can be either the name or the underlying value of an enumeration constant. Všimněte si, že metody analýzy budou úspěšně převádět řetězcové reprezentace čísel, které nejsou členy konkrétního výčtu, pokud je možné řetězce převést na hodnotu základního typu výčtu.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. Chcete-li tomu zabránit, může být volána metoda IsDefined, aby bylo zajištěno, že výsledek metody analýzy je platná hodnota výčtu.To prevent this, the IsDefined method can be called to ensure that the result of the parsing method is a valid enumeration value. Tento příklad znázorňuje tento přístup a ukazuje volání metod Parse(Type, String) a 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. Všimněte si, že metoda neobecného rozboru vrátí objekt, který může být nutné přetypovat ( C#in) nebo převést (v Visual Basic) na příslušný typ výčtu.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

Formátování hodnot výčtuFormatting enumeration values

Hodnoty výčtu můžete převést na vyjádření řetězcových reprezentací voláním metody static Format a také přetížením metody ToString instance.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. Řetězec formátu lze použít k řízení přesného způsobu, jakým je hodnota výčtu vyjádřena jako řetězec.You can use a format string to control the precise way in which an enumeration value is represented as a string. Další informace najdete v tématu řetězce formátu výčtu.For more information, see Enumeration Format Strings. V následujícím příkladu je použit každý z podporovaných řetězců formátu výčtu ("G" nebo "g", "D" nebo "d", "X" nebo "x", "F" nebo "f") pro převod člena ArrivalStatus výčtu na své řetězcové reprezentace.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

Iterace členů výčtuIterating enumeration members

Enum typ neimplementuje rozhraní IEnumerable nebo IEnumerable<T>, které by umožňovalo iteraci členů kolekce pomocí konstruktoru foreach (in C#) nebo 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. Můžete však vytvořit výčet členů jedním ze dvou způsobů.However, you can enumerate members in either of two ways.

  • Můžete zavolat metodu GetNames pro načtení pole řetězců obsahujícího názvy členů výčtu.You can call the GetNames method to retrieve a string array containing the names of the enumeration members. Dále můžete pro každý prvek pole řetězců zavolat metodu Parse pro převod řetězce na jeho ekvivalentní hodnotu výčtu.Next, for each element of the string array, you can call the Parse method to convert the string to its equivalent enumeration value. Tento postup znázorňuje následující příklad.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)      
    
  • Můžete zavolat metodu GetValues pro načtení pole, které obsahuje zdrojové hodnoty ve výčtu.You can call the GetValues method to retrieve an array that contains the underlying values in the enumeration. Dále můžete pro každý prvek pole volat metodu ToObject pro převod celého čísla na odpovídající hodnotu výčtu.Next, for each element of the array, you can call the ToObject method to convert the integer to its equivalent enumeration value. Tento postup znázorňuje následující příklad.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)
    

Nevýhradní členové a atribut FlagsNon-exclusive members and the Flags attribute

Jedním ze společného použití výčtu je reprezentace sady vzájemně se vylučujících hodnot.One common use of an enumeration is to represent a set of mutually exclusive values. Například instance ArrivalStatus může mít hodnotu Early, OnTimenebo Late.For example, an ArrivalStatus instance can have a value of Early, OnTime, or Late. Neposkytuje žádný smysl pro hodnotu instance ArrivalStatus, aby odrážela více než jednu konstantu výčtu.It makes no sense for the value of an ArrivalStatus instance to reflect more than one enumeration constant.

V ostatních případech však hodnota objektu výčtu může zahrnovat více členů výčtu a každý člen představuje bitové pole v hodnotě výčtu.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. Atribut FlagsAttribute lze použít k označení toho, že se výčet skládá z bitových polí.The FlagsAttribute attribute can be used to indicate that the enumeration consists of bit fields. Například výčet s názvem Pets může být použit k označení druhů domácích zvířat v domácnosti.For example, an enumeration named Pets might be used to indicate the kinds of pets in a household. Může být definován následujícím způsobem.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

Výčet Pets lze potom použít, jak je znázorněno v následujícím příkladu.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)      

Následující osvědčené postupy by měly být použity při definování bitového výčtu a použití atributu FlagsAttribute.The following best practices should be used when defining a bitwise enumeration and applying the FlagsAttribute attribute.

  • Použijte vlastní atribut FlagsAttribute pro výčet pouze v případě, že bitová operace (a, nebo, exkluzivní nebo) má být provedena na numerické hodnotě.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.

  • Definujte konstanty výčtu v mocninách dvou, tj. 1, 2, 4, 8 a tak dále.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. To znamená, že jednotlivé příznaky v kombinovaných konstantách výčtu se nepřekrývají.This means the individual flags in combined enumeration constants do not overlap.

  • Zvažte vytvoření výčtové konstanty pro běžně používané kombinace příznaků.Consider creating an enumerated constant for commonly used flag combinations. Například pokud máte výčet, který se používá pro vstupně-výstupní operace se soubory, které obsahují výčtové konstanty Read = 1 a Write = 2, zvažte vytvoření výčtu konstantního ReadWrite = Read OR Write, které kombinuje příznaky Read a 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. Bitová operace, která se používá k kombinování příznaků, může být navíc považována za pokročilý koncept za určitých okolností, které by neměly být požadovány pro jednoduché úlohy.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.

  • Buďte opatrní, pokud definujete záporné číslo jako příznak s výčtovou konstantou, protože mnoho pozic příznaků může být nastavené na 1, což může způsobit matoucí kód a podporovat chyby kódování.Use caution if you define a negative number as a flag enumerated constant because many flag positions might be set to 1, which might make your code confusing and encourage coding errors.

  • Pohodlný způsob, jak otestovat, zda je příznak nastaven v číselné hodnotě, je volat instanci HasFlag metodu, jak je znázorněno v následujícím příkladu.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.      
    

    Je ekvivalentní provedení bitové a operace mezi číselnou hodnotou a výčtovou konstantou, která nastaví všechny bity v číselné hodnotě na nulu, které neodpovídají příznaku a poté testuje, zda je výsledek této operace roven příznak s výčtovou konstantouIt 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. To je znázorněno v následujícím příkladu.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.      
    
  • Použijte None jako název příznaku s výčtovou konstantou, jejíž hodnota je nula.Use None as the name of the flag enumerated constant whose value is zero. Nemůžete použít None výčtu konstant v bitové a operaci pro otestování příznaku, protože výsledek je vždycky nula.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. K určení, zda jsou nastaveny jakékoli bity číselné hodnoty, však lze provést logickou, ne bitovou a relační hodnotu mezi číselnou hodnotou a None výčtovou konstantou.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. To je znázorněno v následujícím příkladu.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.      
    
  • Nedefinujte hodnotu výčtu výhradně pro zrcadlení stavu samotného výčtu.Do not define an enumeration value solely to mirror the state of the enumeration itself. Nedefinujte například výčtovou konstantu, která pouze označí konec výčtu.For example, do not define an enumerated constant that merely marks the end of the enumeration. Pokud potřebujete určit poslední hodnotu výčtu, zkontrolujte tuto hodnotu explicitně.If you need to determine the last value of the enumeration, check for that value explicitly. Kromě toho můžete provést kontrolu rozsahu pro první a poslední výčtovou konstantu, pokud jsou všechny hodnoty v rozsahu platné.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

Přidání metod výčtuAdding enumeration methods

Vzhledem k tomu, že výčtové typy jsou definovány jazykovými strukturami, například enum (C#) a Enum (Visual Basic), nemůžete definovat vlastní metody pro typ výčtu jiný než tyto metody zděděné z třídy 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. Můžete však použít rozšiřující metody pro přidání funkcionality do konkrétního výčtového typu.However, you can use extension methods to add functionality to a particular enumeration type.

V následujícím příkladu výčet Grades představuje možné známky, které může student získat ve třídě.In the following example, the Grades enumeration represents the possible letter grades that a student may receive in a class. Rozšiřující metoda s názvem Passing je přidána do typu Grades tak, že každá instance daného typu teď "ví", zda představuje třídu předání nebo ne.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. Třída Extensions obsahuje také statickou proměnnou pro čtení a zápis, která definuje minimální stupeň předávání.The Extensions class also contains a static read-write variable that defines the minimum passing grade. Návratová hodnota metody rozšíření Passing odráží aktuální hodnotu této proměnné.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.

Konstruktory

Enum()

Inicializuje novou instanci třídy Enum třídy.Initializes a new instance of the Enum class.

Metody

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.Returns a value indicating whether this instance is equal to a specified object.

Format(Type, Object, String)

Převede zadanou hodnotu zadaného výčtového typu na odpovídající řetězcovou reprezentaci podle zadaného formátu.Converts the specified value of a specified enumerated type to its equivalent string representation according to the specified format.

GetHashCode()

Vrátí hodnotu hash hodnoty této instance.Returns the hash code for the value of this instance.

GetName(Type, Object)

Načte název konstanty v zadaném výčtu, který má zadanou hodnotu.Retrieves the name of the constant in the specified enumeration that has the specified value.

GetNames(Type)

Načte pole názvů konstant v zadaném výčtu.Retrieves an array of the names of the constants in a specified enumeration.

GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Zděděno od Object)
GetTypeCode()

Vrátí kód typu nadřazeného typu tohoto člena výčtu.Returns the type code of the underlying type of this enumeration member.

GetUnderlyingType(Type)

Vrátí nadřízený typ zadaného výčtu.Returns the underlying type of the specified enumeration.

GetValues(Type)

Načte pole hodnot konstant v zadaném výčtu.Retrieves an array of the values of the constants in a specified enumeration.

HasFlag(Enum)

Určuje, zda je v aktuální instanci nastaveno jedno nebo více bitových polí.Determines whether one or more bit fields are set in the current instance.

IsDefined(Type, Object)

Vrátí logickou hodnotu, která oznamuje, zda daná celočíselná hodnota nebo její název jako řetězec existuje v zadaném výčtu.Returns a Boolean telling whether a given integral value, or its name as a string, exists in a specified enumeration.

MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
Parse(Type, String)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.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)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Parametr určuje, zda se u operace nerozlišují velká a malá písmena.A parameter specifies whether the operation is case-insensitive.

Parse<TEnum>(String)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo více výčtových konstant určených parametrem TEnum na ekvivalentní Výčtový objekt.Converts the string representation of the name or numeric value of one or more enumerated constants specified by TEnum to an equivalent enumerated object.

Parse<TEnum>(String, Boolean)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo více výčtových konstant určených parametrem TEnum na ekvivalentní Výčtový objekt.Converts the string representation of the name or numeric value of one or more enumerated constants specified by TEnum to an equivalent enumerated object. Parametr určuje, zda se u operace nerozlišují velká a malá písmena.A parameter specifies whether the operation is case-insensitive.

ToObject(Type, Byte)

Převede zadaný 8bitový unsigned integer na člen výčtu.Converts the specified 8-bit unsigned integer to an enumeration member.

ToObject(Type, Int16)

Převede zadané 16bitové celé číslo se znaménkem na člen výčtu.Converts the specified 16-bit signed integer to an enumeration member.

ToObject(Type, Int32)

Převede zadané celé číslo se znaménkem 32 na člen výčtu.Converts the specified 32-bit signed integer to an enumeration member.

ToObject(Type, Int64)

Převede zadané celé číslo se znaménkem 64 na člen výčtu.Converts the specified 64-bit signed integer to an enumeration member.

ToObject(Type, Object)

Převede zadaný objekt s celočíselnou hodnotou na člen výčtu.Converts the specified object with an integer value to an enumeration member.

ToObject(Type, SByte)

Převede zadané 8bitové celočíselné hodnoty se znaménkem na člen výčtu.Converts the specified 8-bit signed integer value to an enumeration member.

ToObject(Type, UInt16)

Převede zadanou 16bitová hodnotu unsigned integer na člen výčtu.Converts the specified 16-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt32)

Převede zadanou hodnotu 32 unsigned integer na člen výčtu.Converts the specified 32-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt64)

Převede zadanou hodnotu 64 unsigned integer na člen výčtu.Converts the specified 64-bit unsigned integer value to an enumeration member.

ToString()

Převede hodnotu této instance na její odpovídající řetězcovou reprezentaci.Converts the value of this instance to its equivalent string representation.

ToString(IFormatProvider)

Toto přetížení metody je zastaralé; Použijte ToString().This method overload is obsolete; use ToString().

ToString(String)

Převede hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí zadaného formátu.Converts the value of this instance to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

Toto přetížení metody je zastaralé; Použijte ToString(String).This method overload is obsolete; use ToString(String).

TryParse(Type, String, Boolean, Object)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.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)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.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)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Parametr určuje, zda se u operace rozlišují velká a malá písmena.A parameter specifies whether the operation is case-sensitive. Vrácená hodnota označuje, zda převod proběhl úspěšně.The return value indicates whether the conversion succeeded.

TryParse<TEnum>(String, TEnum)

Převede řetězcovou reprezentaci názvu nebo číselné hodnoty jedné nebo několika konstant výčtu na ekvivalentní objekt výčtu.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Vrácená hodnota označuje, zda převod proběhl úspěšně.The return value indicates whether the conversion succeeded.

Explicitní implementace rozhraní

IConvertible.GetTypeCode()

Vrátí kód typu této instance Enum.Returns the type code of this Enum instance.

IConvertible.ToBoolean(IFormatProvider)

Převede aktuální hodnotu na logickou hodnotu založenou na základním typu.Converts the current value to a Boolean value based on the underlying type.

IConvertible.ToByte(IFormatProvider)

Převede aktuální hodnotu na 8bitové unsigned integer na základě základního typu.Converts the current value to an 8-bit unsigned integer based on the underlying type.

IConvertible.ToChar(IFormatProvider)

Převede aktuální hodnotu na znak Unicode založený na základním typu.Converts the current value to a Unicode character based on the underlying type.

IConvertible.ToDateTime(IFormatProvider)

Převede aktuální hodnotu na DateTime na základě základního typu.Converts the current value to a DateTime based on the underlying type.

IConvertible.ToDecimal(IFormatProvider)

Převede aktuální hodnotu na Decimal na základě základního typu.Converts the current value to a Decimal based on the underlying type.

IConvertible.ToDouble(IFormatProvider)

Převede aktuální hodnotu na číslo s dvojitou přesností a plovoucí desetinnou čárkou na základě základního typu.Converts the current value to a double-precision floating point number based on the underlying type.

IConvertible.ToInt16(IFormatProvider)

Převede aktuální hodnotu na 16bitové celé číslo se znaménkem na základě základního typu.Converts the current value to a 16-bit signed integer based on the underlying type.

IConvertible.ToInt32(IFormatProvider)

Převede aktuální hodnotu na celé číslo se znaménkem 32 na základě základního typu.Converts the current value to a 32-bit signed integer based on the underlying type.

IConvertible.ToInt64(IFormatProvider)

Převede aktuální hodnotu na celé číslo se znaménkem 64 na základě základního typu.Converts the current value to a 64-bit signed integer based on the underlying type.

IConvertible.ToSByte(IFormatProvider)

Převede aktuální hodnotu na 8bitové celé číslo se znaménkem na základě základního typu.Converts the current value to an 8-bit signed integer based on the underlying type.

IConvertible.ToSingle(IFormatProvider)

Převede aktuální hodnotu na číslo s jednoduchou přesností s plovoucí desetinnou čárkou na základě základního typu.Converts the current value to a single-precision floating-point number based on the underlying type.

IConvertible.ToString(IFormatProvider)

Toto přetížení metody je zastaralé; místo toho použijte ToString().This method overload is obsolete; use ToString() instead.

IConvertible.ToType(Type, IFormatProvider)

Převede aktuální hodnotu na zadaný typ na základě základního typu.Converts the current value to a specified type based on the underlying type.

IConvertible.ToUInt16(IFormatProvider)

Převede aktuální hodnotu na 16bitový unsigned integer na základě základního typu.Converts the current value to a 16-bit unsigned integer based on the underlying type.

IConvertible.ToUInt32(IFormatProvider)

Převede aktuální hodnotu na 32 unsigned integer na základě základního typu.Converts the current value to a 32-bit unsigned integer based on the underlying type.

IConvertible.ToUInt64(IFormatProvider)

Převede aktuální hodnotu na 64 unsigned integer na základě základního typu.Converts the current value to a 64-bit unsigned integer based on the underlying type.

IFormattable.ToString(String, IFormatProvider)

Toto přetížení metody je zastaralé; Použijte ToString(String).This method overload is obsolete; use ToString(String).

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.This type is thread safe.

Viz také