Enum Klasa

Definicja

Dostarcza klasę bazową dla wyliczeń.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
Dziedziczenie
Pochodne
Atrybuty
Implementuje

Przykłady

Poniższy przykład ilustruje użycie wyliczenia do reprezentowania nazwanych wartości i inne Wyliczenie do reprezentowania pól bitów nazwanych.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 

Uwagi

Wyliczenie jest zestawem nazwanych stałych, których typem podstawowym jest dowolny typ całkowity.An enumeration is a set of named constants whose underlying type is any integral type. Jeśli żaden typ podstawowy nie jest zadeklarowany w sposób jawny, zostanie użyta Int32.If no underlying type is explicitly declared, Int32 is used. Enum jest klasą bazową dla wszystkich wyliczeń w .NET Framework.Enum is the base class for all enumerations in the .NET Framework. Typy wyliczeniowe są definiowane za pomocą słowa C# kluczowego enum w i Enum...End Enum konstrukcji w Visual Basic.Enumeration types are defined by the enum keyword in C# and the Enum...End Enum construct in Visual Basic.

Enum udostępnia metody porównujące wystąpienia tej klasy, konwertując wartość wystąpienia na jego reprezentację w postaci ciągu, konwertując ciąg reprezentujący liczbę na wystąpienie tej klasy i tworząc wystąpienie określonego wyliczenia i wartości.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.

Można również traktować Wyliczenie jako pole bitowe.You can also treat an enumeration as a bit field. Aby uzyskać więcej informacji, zobacz sekcję niewyłączne elementy członkowskie i atrybuty flag oraz temat FlagsAttribute.For more information, see the Non-Exclusive Members and the Flags Attribute section and the FlagsAttribute topic.

W tym temacie:In this topic:

Tworzenie typu wyliczeniowego Creating an enumeration type
Tworzenie wystąpienia typu wyliczeniowego Instantiating an enumeration type
Najlepsze rozwiązania w zakresie wyliczania Enumeration best practices
Wykonywanie operacji z wyliczeniami Performing operations with enumerations
Wykonywanie konwersjiPerforming conversions
Analizowanie wartości wyliczeniaParsing enumeration values
Formatowanie wartości wyliczeniaFormatting enumeration values
Iterowanie elementów członkowskich wyliczeniaIterating enumeration members
Niewyłączne elementy członkowskie i atrybuty flagNon-exclusive members and the Flags attribute
Dodawanie metod wyliczeniaAdding enumeration methods

Tworzenie typu wyliczeniaCreating an enumeration type

Języki programowania zwykle zapewniają składnię, która deklaruje Wyliczenie, które składa się z zestawu nazwanych stałych i ich wartości.Programming languages typically provide syntax to declare an enumeration that consists of a set of named constants and their values. Poniższy przykład ilustruje składnię używaną przez C# i Visual Basic, aby zdefiniować Wyliczenie.The following example illustrates the syntax used by C# and Visual Basic to define an enumeration. Tworzy Wyliczenie o nazwie ArrivalStatus, które ma trzy elementy członkowskie: ArrivalStatus.Early, ArrivalStatus.OnTimei ArrivalStatus.Late.It creates an enumeration named ArrivalStatus that has three members: ArrivalStatus.Early, ArrivalStatus.OnTime, and ArrivalStatus.Late. Należy zauważyć, że w obu przypadkach Wyliczenie nie dziedziczy jawnie po Enum; Relacja dziedziczenia jest obsługiwana niejawnie przez kompilator.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

Ostrzeżenie

Nigdy nie należy tworzyć typu wyliczenia, którego typ podstawowy jest niecałkowity lub Char.You should never create an enumeration type whose underlying type is non-integral or Char. Chociaż można utworzyć taki typ wyliczenia przy użyciu odbicia, wywołania metod, które używają typu wyniku, są wiarygodne i mogą również generować dodatkowe wyjątki.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.

Tworzenie wystąpienia typu wyliczeniowegoInstantiating an enumeration type

Typ wyliczenia można utworzyć tak samo jak w przypadku wystąpienia dowolnego innego typu wartości: przez zadeklarowanie zmiennej i przypisanie jednej z jej stałych.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. Poniższy przykład tworzy wystąpienie ArrivalStatus którego wartość jest 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)

Możesz również utworzyć wystąpienie wartości wyliczenia w następujący sposób:You can also instantiate an enumeration value in the following ways:

  • Przy użyciu określonych funkcji języka programowania do rzutowania (jak w programie C#) lub konwersji (jak w Visual Basic) wartość całkowita na wartość wyliczenia.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. Poniższy przykład tworzy obiekt ArrivalStatus, którego wartość jest ArrivalStatus.Early w ten sposób.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)
    
  • Wywoływanie niejawnego konstruktora bez parametrów.By calling its implicit parameterless constructor. Jak pokazano w poniższym przykładzie, w tym przypadku podstawową wartością wystąpienia wyliczenia jest 0.As the following example shows, in this case the underlying value of the enumeration instance is 0. Nie jest to jednak konieczność prawidłowej stałej w wyliczeniu.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)
    
  • Wywołując metodę Parse lub TryParse, aby przeanalizować ciąg, który zawiera nazwę stałej w wyliczeniu.By calling the Parse or TryParse method to parse a string that contains the name of a constant in the enumeration. Aby uzyskać więcej informacji, zobacz sekcję Analizowanie wartości wyliczenia .For more information, see the Parsing Enumeration Values section.

  • Wywołując metodę ToObject, aby przekonwertować wartość całkowitą na typ wyliczeniowy.By calling the ToObject method to convert an integral value to an enumeration type. Aby uzyskać więcej informacji, zobacz sekcję wykonywanie konwersji .For more information, see the Performing Conversions section.

Najlepsze rozwiązania w zakresie wyliczaniaEnumeration best practices

Zalecamy stosowanie następujących najlepszych rozwiązań podczas definiowania typów wyliczeniowych:We recommend that you use the following best practices when you define enumeration types:

  • Jeśli nie zdefiniowano elementu członkowskiego wyliczenia, którego wartość wynosi 0, rozważ utworzenie None stałej.If you have not defined an enumeration member whose value is 0, consider creating a None enumerated constant. Domyślnie pamięć użyta do wyliczenia jest inicjowana do zera przez środowisko uruchomieniowe języka wspólnego.By default, the memory used for the enumeration is initialized to zero by the common language runtime. W związku z tym, jeśli nie zdefiniujesz stałej, której wartość wynosi zero, Wyliczenie będzie zawierać niedozwoloną wartość podczas tworzenia.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • Jeśli występuje oczywisty przypadek domyślny, który aplikacja musi reprezentować, rozważ użycie stałej wyliczanej, której wartość jest równa zero, aby przedstawić ją.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. Jeśli nie ma domyślnego przypadku, rozważ użycie stałej wyliczenia, której wartość jest równa zero, aby określić przypadek, który nie jest reprezentowany przez żadną z innych stałych wyliczeniowych.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.

  • Nie określaj stałych, które są zarezerwowane do użytku w przyszłości.Do not specify enumerated constants that are reserved for future use.

  • Podczas definiowania metody lub właściwości, która pobiera stałą jako wartość, należy rozważyć sprawdzenie poprawności wartości.When you define a method or property that takes an enumerated constant as a value, consider validating the value. Przyczyną jest to, że można rzutować wartość liczbową na typ wyliczeniowy, nawet jeśli ta wartość liczbowa nie jest zdefiniowana w wyliczeniu.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.

Dodatkowe najlepsze rozwiązania dla typów wyliczeniowych, których stałe są polami bitowymi, znajdują się w niewyłącznym elemencie członkowskim i sekcji flags .Additional best practices for enumeration types whose constants are bit fields are listed in the Non-Exclusive Members and the Flags Attribute section.

Wykonywanie operacji z wyliczeniamiPerforming operations with enumerations

Podczas tworzenia wyliczenia nie można definiować nowych metod.You cannot define new methods when you are creating an enumeration. Jednak typ wyliczeniowy dziedziczy kompletny zestaw metod static i instance z klasy Enum.However, an enumeration type inherits a complete set of static and instance methods from the Enum class. W poniższych sekcjach opisano większość tych metod, a także kilka innych metod, które są często używane podczas pracy z wartościami wyliczenia.The following sections survey most of these methods, in addition to several other methods that are commonly used when working with enumeration values.

Wykonywanie konwersjiPerforming conversions

Można konwertować między wyliczeniem składowej a jego typem podstawowym przy użyciu operatora rzutowania ( C#in) lub konwersji (w 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. Poniższy przykład używa rzutowania lub operatory konwersji do wykonania konwersji zarówno z liczby całkowitej na wartość wyliczenia, jak i z wartości wyliczenia na liczbę całkowitą.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)

Klasa Enum zawiera również metodę ToObject, która konwertuje wartość dowolnego typu całkowitego na wartość wyliczenia.The Enum class also includes a ToObject method that converts a value of any integral type to an enumeration value. W poniższym przykładzie zastosowano metodę ToObject(Type, Int32), aby skonwertować Int32 do wartości ArrivalStatus.The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. Należy zauważyć, że ponieważ ToObject zwraca wartość typu Object, użycie operatora rzutowania lub konwersji może być nadal konieczne do rzutowania obiektu na typ wyliczeniowy.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)

Podczas konwertowania liczby całkowitej na wartość wyliczenia można przypisać wartość, która nie jest w rzeczywistości elementem członkowskim wyliczenia.When converting an integer to an enumeration value, it is possible to assign a value that is not actually a member of the enumeration. Aby tego uniknąć, można przekazać liczbę całkowitą do metody IsDefined przed przeprowadzeniem konwersji.To prevent this, you can pass the integer to the IsDefined method before performing the conversion. Poniższy przykład używa tej metody, aby określić, czy elementy tablicy wartości całkowitych mogą być konwertowane na wartości 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

Chociaż Klasa Enum zapewnia jawne implementacje interfejsu interfejsu IConvertible do konwersji z wartości wyliczenia na typ całkowity, należy użyć metod klasy Convert, takich jak ToInt32, do wykonania tych konwersji.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. Poniższy przykład ilustruje, jak można użyć metody GetUnderlyingType wraz z metodą Convert.ChangeType, aby przekonwertować wartość wyliczenia na jej typ podstawowy.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. Należy zauważyć, że ten przykład nie wymaga, aby typ podstawowy wyliczenia był znany w czasie kompilacji.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

Analizowanie wartości wyliczeniaParsing enumeration values

Metody Parse i TryParse umożliwiają konwertowanie ciągu reprezentującego wartość wyliczenia na tę wartość.The Parse and TryParse methods allow you to convert the string representation of an enumeration value to that value. Reprezentacja ciągu może być nazwą lub podstawową wartością stałej wyliczenia.The string representation can be either the name or the underlying value of an enumeration constant. Należy zauważyć, że metody analizy pomyślnie konwertują reprezentacje ciągów liczb, które nie są elementami członkowskimi określonego wyliczenia, jeśli ciągi mogą być konwertowane na wartość typu podstawowego wyliczenia.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. Aby tego uniknąć, można wywołać metodę IsDefined, aby upewnić się, że wynik metody analizy jest prawidłową wartością wyliczenia.To prevent this, the IsDefined method can be called to ensure that the result of the parsing method is a valid enumeration value. Przykład ilustruje to podejście i demonstruje wywołania zarówno metody Parse(Type, String), jak i 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. Należy zauważyć, że metoda analizy niegenerycznej zwraca obiekt, który może być konieczne do rzutowania C#(w) lub przekonwertować (w Visual Basic) na odpowiedni typ wyliczeniowy.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

Formatowanie wartości wyliczeniaFormatting enumeration values

Można przekonwertować wartości wyliczenia na ich reprezentacje ciągów, wywołując metodę static Format, a także przeciążenia metody ToString wystąpienia.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. Możesz użyć ciągu formatu, aby kontrolować precyzyjną metodę, w której wartość wyliczenia jest reprezentowana jako ciąg.You can use a format string to control the precise way in which an enumeration value is represented as a string. Aby uzyskać więcej informacji, zobacz ciągi formatujące Wyliczenie.For more information, see Enumeration Format Strings. W poniższym przykładzie zastosowano wszystkie obsługiwane ciągi formatujące Wyliczenie ("G" lub "g", "D" lub "d", "X", "x", "F" lub "f") w celu przekonwertowania elementu członkowskiego wyliczenia ArrivalStatus na jego reprezentacje ciągów.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

Iterowanie elementów członkowskich wyliczeniaIterating enumeration members

Typ Enum nie implementuje interfejsu IEnumerable lub IEnumerable<T>, co pozwoli na iterację elementów członkowskich kolekcji przy użyciu foreach (w C#) lub For Each (w 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. Można jednak wyliczać składowe na jeden z dwóch sposobów.However, you can enumerate members in either of two ways.

  • Można wywołać metodę GetNames, aby pobrać tablicę ciągów zawierającą nazwy elementów członkowskich wyliczenia.You can call the GetNames method to retrieve a string array containing the names of the enumeration members. Następnie dla każdego elementu tablicy ciągów można wywołać metodę Parse, aby przekonwertować ciąg na jego równoważną wartość wyliczenia.Next, for each element of the string array, you can call the Parse method to convert the string to its equivalent enumeration value. To podejście pokazano w poniższym przykładzie.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)      
    
  • Możesz wywołać metodę GetValues, aby pobrać tablicę, która zawiera podstawowe wartości w wyliczeniu.You can call the GetValues method to retrieve an array that contains the underlying values in the enumeration. Następnie dla każdego elementu tablicy można wywołać metodę ToObject, aby przekonwertować liczbę całkowitą na jej równoważną wartość wyliczenia.Next, for each element of the array, you can call the ToObject method to convert the integer to its equivalent enumeration value. To podejście pokazano w poniższym przykładzie.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)
    

Niewyłączne elementy członkowskie i atrybuty flagNon-exclusive members and the Flags attribute

Typowym zastosowaniem wyliczenia jest przedstawienie zestawu wzajemnie wykluczających się wartości.One common use of an enumeration is to represent a set of mutually exclusive values. Na przykład wystąpienie ArrivalStatus może mieć wartość Early, OnTimelub Late.For example, an ArrivalStatus instance can have a value of Early, OnTime, or Late. Nie ma sensu, aby wartość wystąpienia ArrivalStatus nie odzwierciedlała więcej niż jednej stałej wyliczenia.It makes no sense for the value of an ArrivalStatus instance to reflect more than one enumeration constant.

Jednak w innych przypadkach wartość obiektu wyliczenia może zawierać wiele elementów członkowskich wyliczenia, a każdy element członkowski reprezentuje pole bitowe w wartości wyliczenia.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. Atrybutu FlagsAttribute można użyć, aby wskazać, że Wyliczenie składa się z pól bitowych.The FlagsAttribute attribute can be used to indicate that the enumeration consists of bit fields. Na przykład Wyliczenie o nazwie Pets może być używane do wskazywania rodzajów zwierząt domowych w gospodarstwie domowym.For example, an enumeration named Pets might be used to indicate the kinds of pets in a household. Można je zdefiniować w następujący sposób.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

Wyliczenie Pets można następnie użyć, jak pokazano w poniższym przykładzie.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)      

Podczas definiowania wyliczenia bitowego i stosowania atrybutu FlagsAttribute należy stosować następujące najlepsze rozwiązania.The following best practices should be used when defining a bitwise enumeration and applying the FlagsAttribute attribute.

  • Użyj FlagsAttribute atrybutu niestandardowego dla wyliczenia tylko wtedy, gdy operacja bitowa (oraz, lub, wyłącz lub) ma zostać wykonana na wartości liczbowej.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.

  • Zdefiniuj stałe wyliczenia w uprawnieniach dwóch, czyli 1, 2, 4, 8 itd.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. Oznacza to, że poszczególne flagi w połączonych stałych wyliczenia nie nakładają się na siebie.This means the individual flags in combined enumeration constants do not overlap.

  • Rozważ utworzenie stałej wyliczenia dla często używanych kombinacji flag.Consider creating an enumerated constant for commonly used flag combinations. Na przykład, jeśli masz Wyliczenie używane dla operacji we/wy plików, które zawierają stałe wyliczane Read = 1 i Write = 2, rozważ utworzenie stałej ReadWrite = Read OR Write, która łączy flagi Read i 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. Ponadto bitowe lub operacje używane do łączenia flag mogą być uznawane za zaawansowaną koncepcję w pewnych okolicznościach, które nie powinny być wymagane w przypadku prostych zadań.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.

  • Należy zachować ostrożność, jeśli zdefiniujesz liczbę ujemną jako stałą jako flagę, ponieważ wiele pozycji flagi może być ustawiona na 1, co może sprawiać, że kod jest mylący i zachęca do błędów kodowania.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.

  • Wygodnym sposobem sprawdzenia, czy flaga jest ustawiona w wartości liczbowej, jest wywołanie metody HasFlag, jak pokazano w poniższym przykładzie.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.      
    

    Jest to równoznaczne z wykonywaniem bitowej i operacji między wartością liczbową i stałą oznaczającą flagą, która ustawia wszystkie bity w wartości liczbowej na zero, które nie odpowiadają flagze, a następnie testuje, czy wynik tej operacji jest równy Oznacz stałą jako flagę.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. Jest to zilustrowane w poniższym przykładzie.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.      
    
  • Użyj None jako nazwy stałej wyliczeniowej flagi, której wartość jest równa zero.Use None as the name of the flag enumerated constant whose value is zero. Nie można użyć None wyliczeniowej stałej w koniunkcji bitowej i do przetestowania flagi, ponieważ wynik jest zawsze równy zero.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. Można jednak wykonać logiczne, a nie bitowe, porównanie między wartością liczbową i None wyliczeniem, aby określić, czy wszystkie bity w wartości liczbowej są ustawione.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. Jest to zilustrowane w poniższym przykładzie.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.      
    
  • Nie należy definiować wartości wyliczenia wyłącznie w celu dublowania stanu samego wyliczenia.Do not define an enumeration value solely to mirror the state of the enumeration itself. Na przykład nie należy definiować stałej wyliczenia, która jedynie oznacza koniec wyliczenia.For example, do not define an enumerated constant that merely marks the end of the enumeration. Jeśli musisz określić ostatnią wartość wyliczenia, sprawdź tę wartość jawnie.If you need to determine the last value of the enumeration, check for that value explicitly. Ponadto można przeprowadzić Sprawdzanie zakresu dla pierwszej i ostatniej wyliczanej stałej, jeśli wszystkie wartości w zakresie są prawidłowe.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

Dodawanie metod wyliczeniaAdding enumeration methods

Ponieważ typy wyliczeniowe są zdefiniowane przez struktury języka, takie jakC#enum () i Enum (Visual Basic), nie można definiować metod niestandardowych dla typu wyliczenia innego niż metody dziedziczone z klasy 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. Można jednak użyć metod rozszerzających, aby dodać funkcjonalność do określonego typu wyliczeniowego.However, you can use extension methods to add functionality to a particular enumeration type.

W poniższym przykładzie Wyliczenie Grades reprezentuje możliwe klasy liter, które student może otrzymać w klasie.In the following example, the Grades enumeration represents the possible letter grades that a student may receive in a class. Metoda rozszerzająca o nazwie Passing jest dodawana do typu Grades, tak aby każde wystąpienie tego typu było teraz "znane", niezależnie od tego, czy reprezentuje ona przewagę, czy nie.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. Klasa Extensions zawiera również statyczną zmienną do odczytu i zapisu, która definiuje minimalną ocenę.The Extensions class also contains a static read-write variable that defines the minimum passing grade. Wartość zwracana metody rozszerzenia Passing odzwierciedla bieżącą wartość tej zmiennej.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()

Inicjuje nowe wystąpienie klasy Enum klasy.Initializes a new instance of the Enum class.

Metody

CompareTo(Object)

Porównuje to wystąpienie z określonym obiektem i zwraca wskazanie ich względnych wartości.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.Returns a value indicating whether this instance is equal to a specified object.

Format(Type, Object, String)

Konwertuje określoną wartość określonego typu wyliczeniowego na odpowiadającą reprezentację ciągu zgodną z określonym formatem.Converts the specified value of a specified enumerated type to its equivalent string representation according to the specified format.

GetHashCode()

Zwraca kod skrótu dla wartości tego wystąpienia.Returns the hash code for the value of this instance.

GetName(Type, Object)

Pobiera nazwę stałej w określonym wyliczeniu, która ma określoną wartość.Retrieves the name of the constant in the specified enumeration that has the specified value.

GetNames(Type)

Pobiera tablicę nazw stałych w określonym wyliczeniu.Retrieves an array of the names of the constants in a specified enumeration.

GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
GetTypeCode()

Zwraca kod typu podstawowego elementu członkowskiego wyliczenia.Returns the type code of the underlying type of this enumeration member.

GetUnderlyingType(Type)

Zwraca typ podstawowy określonego wyliczenia.Returns the underlying type of the specified enumeration.

GetValues(Type)

Pobiera tablicę wartości stałych w określonym wyliczeniu.Retrieves an array of the values of the constants in a specified enumeration.

HasFlag(Enum)

Określa, czy w bieżącym wystąpieniu są ustawione co najmniej jedno pole bitowe.Determines whether one or more bit fields are set in the current instance.

IsDefined(Type, Object)

Zwraca wartość Boolean wskazująca, czy dana wartość całkowita, czy jej nazwa jako ciąg, istnieją w określonym wyliczeniu.Returns a Boolean telling whether a given integral value, or its name as a string, exists in a specified enumeration.

MemberwiseClone()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
Parse(Type, String)

Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.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)

Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Parametr określa, czy operacja nie uwzględnia wielkości liter.A parameter specifies whether the operation is case-insensitive.

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

Konwertuje określoną 8-bitową liczbę całkowitą bez znaku na składowaną Wyliczenie.Converts the specified 8-bit unsigned integer to an enumeration member.

ToObject(Type, Int16)

Konwertuje określoną 16-bitową liczbę całkowitą ze znakiem na składowaną Wyliczenie.Converts the specified 16-bit signed integer to an enumeration member.

ToObject(Type, Int32)

Konwertuje określoną 32-bitową liczbę całkowitą ze znakiem na składowaną Wyliczenie.Converts the specified 32-bit signed integer to an enumeration member.

ToObject(Type, Int64)

Konwertuje określoną 64-bitową liczbę całkowitą ze znakiem na składowaną Wyliczenie.Converts the specified 64-bit signed integer to an enumeration member.

ToObject(Type, Object)

Konwertuje określony obiekt z wartością całkowitą na Wyliczenie elementu członkowskiego.Converts the specified object with an integer value to an enumeration member.

ToObject(Type, SByte)

Konwertuje określoną 8-bitową liczbę całkowitą ze znakiem na składowaną Wyliczenie.Converts the specified 8-bit signed integer value to an enumeration member.

ToObject(Type, UInt16)

Konwertuje określoną 16-bitową liczbę całkowitą bez znaku na składowaną Wyliczenie.Converts the specified 16-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt32)

Konwertuje określoną 32-bitową liczbę całkowitą bez znaku na składowaną Wyliczenie.Converts the specified 32-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt64)

Konwertuje określoną 64-bitową liczbę całkowitą bez znaku na składowaną Wyliczenie.Converts the specified 64-bit unsigned integer value to an enumeration member.

ToString()

Konwertuje wartość tego wystąpienia na jego równoważną reprezentację w postaci ciągu.Converts the value of this instance to its equivalent string representation.

ToString(IFormatProvider)

To Przeciążenie metody jest przestarzałe; Użyj ToString().This method overload is obsolete; use ToString().

ToString(String)

Konwertuje wartość tego wystąpienia na jego równoważną reprezentację w postaci ciągu przy użyciu podanego formatu.Converts the value of this instance to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

To Przeciążenie metody jest przestarzałe; Użyj ToString(String).This method overload is obsolete; use ToString(String).

TryParse(Type, String, Boolean, Object)

Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.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)

Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.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)

Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Parametr określa, czy w operacji jest rozróżniana wielkość liter.A parameter specifies whether the operation is case-sensitive. Zwracana wartość wskazuje, czy konwersja powiodła się.The return value indicates whether the conversion succeeded.

TryParse<TEnum>(String, TEnum)

Konwertuje ciąg znaków reprezentujący nazwę lub wartość liczbową jednej lub więcej stałych wyliczeniowych dla równoważnego obiektu wyliczanego.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Zwracana wartość wskazuje, czy konwersja powiodła się.The return value indicates whether the conversion succeeded.

Jawne implementacje interfejsu

IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Konwertuje bieżącą wartość na wartość logiczną na podstawie typu podstawowego.Converts the current value to a Boolean value based on the underlying type.

IConvertible.ToByte(IFormatProvider)

Konwertuje bieżącą wartość na 8-bitową liczbę całkowitą bez znaku na podstawie typu podstawowego.Converts the current value to an 8-bit unsigned integer based on the underlying type.

IConvertible.ToChar(IFormatProvider)

Konwertuje bieżącą wartość na znak Unicode w oparciu o typ podstawowy.Converts the current value to a Unicode character based on the underlying type.

IConvertible.ToDateTime(IFormatProvider)

Konwertuje bieżącą wartość na DateTime w oparciu o typ podstawowy.Converts the current value to a DateTime based on the underlying type.

IConvertible.ToDecimal(IFormatProvider)

Konwertuje bieżącą wartość na Decimal w oparciu o typ podstawowy.Converts the current value to a Decimal based on the underlying type.

IConvertible.ToDouble(IFormatProvider)

Konwertuje bieżącą wartość na liczbę zmiennoprzecinkową o podwójnej precyzji na podstawie typu podstawowego.Converts the current value to a double-precision floating point number based on the underlying type.

IConvertible.ToInt16(IFormatProvider)

Konwertuje bieżącą wartość na 16-bitową liczbę całkowitą ze znakiem na podstawie typu podstawowego.Converts the current value to a 16-bit signed integer based on the underlying type.

IConvertible.ToInt32(IFormatProvider)

Konwertuje bieżącą wartość na 32-bitową liczbę całkowitą ze znakiem na podstawie typu podstawowego.Converts the current value to a 32-bit signed integer based on the underlying type.

IConvertible.ToInt64(IFormatProvider)

Konwertuje bieżącą wartość na 64-bitową liczbę całkowitą ze znakiem na podstawie typu podstawowego.Converts the current value to a 64-bit signed integer based on the underlying type.

IConvertible.ToSByte(IFormatProvider)

Konwertuje bieżącą wartość na 8-bitową liczbę całkowitą ze znakiem na podstawie typu podstawowego.Converts the current value to an 8-bit signed integer based on the underlying type.

IConvertible.ToSingle(IFormatProvider)

Konwertuje bieżącą wartość na liczbę zmiennoprzecinkową o pojedynczej precyzji na podstawie typu podstawowego.Converts the current value to a single-precision floating-point number based on the underlying type.

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

Konwertuje bieżącą wartość na określony typ na podstawie typu podstawowego.Converts the current value to a specified type based on the underlying type.

IConvertible.ToUInt16(IFormatProvider)

Konwertuje bieżącą wartość na 16-bitową liczbę całkowitą bez znaku na podstawie typu podstawowego.Converts the current value to a 16-bit unsigned integer based on the underlying type.

IConvertible.ToUInt32(IFormatProvider)

Konwertuje bieżącą wartość na 32-bitową liczbę całkowitą bez znaku na podstawie typu podstawowego.Converts the current value to a 32-bit unsigned integer based on the underlying type.

IConvertible.ToUInt64(IFormatProvider)

Konwertuje bieżącą wartość na 64-bitową liczbę całkowitą bez znaku na podstawie typu podstawowego.Converts the current value to a 64-bit unsigned integer based on the underlying type.

IFormattable.ToString(String, IFormatProvider)

To Przeciążenie metody jest przestarzałe; Użyj ToString(String).This method overload is obsolete; use ToString(String).

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.This type is thread safe.

Zobacz też