Enum.Parse Metodo

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente.

Overload

Parse(Type, ReadOnlySpan<Char>)	Converte l'intervallo di rappresentazione di caratteri del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente.
Parse(Type, String)	Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente.
Parse(Type, ReadOnlySpan<Char>, Boolean)	Converte l'intervallo di rappresentazione di caratteri del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.
Parse(Type, String, Boolean)	Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.
Parse<TEnum>(String, Boolean)	Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate specificate da TEnumin un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.
Parse<TEnum>(ReadOnlySpan<Char>, Boolean)	Converte l'intervallo di caratteri di rappresentazione del nome o del valore numerico di una o più costanti enumerate specificate da TEnum in un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.
Parse<TEnum>(ReadOnlySpan<Char>)	Converte l'intervallo di caratteri di rappresentazione del nome o del valore numerico di una o più costanti enumerate specificate da TEnum in un oggetto enumerato equivalente.
Parse<TEnum>(String)	Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate specificate da TEnumin un oggetto enumerato equivalente.

Parse(Type, ReadOnlySpan<Char>)

Source:

Enum.cs

Converte l'intervallo di rappresentazione di caratteri del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente.

public:
 static System::Object ^ Parse(Type ^ enumType, ReadOnlySpan<char> value);

public static object Parse (Type enumType, ReadOnlySpan<char> value);

static member Parse : Type * ReadOnlySpan<char> -> obj

Public Shared Function Parse (enumType As Type, value As ReadOnlySpan(Of Char)) As Object

Parametri

enumType

Type

Tipo di enumerazione.

value

ReadOnlySpan<Char>

Intervallo contenente il nome o il valore da convertire.

Restituisce

Object

Oggetto di tipo enumType il cui valore è rappresentato da value.

Eccezioni

ArgumentNullException

enumType è null.

ArgumentException

enumType non è un elemento Enum.

ArgumentException

value è una stringa vuota o contiene solo spazi vuoti.

ArgumentException

value è un nome, ma non una delle costanti denominate definite per l'enumerazione.

OverflowException

value non è compreso nell'intervallo del tipo sottostante di enumType.

InvalidOperationException

.NET 8 e versioni successive: enumType è un tipo di enumerazione booleano supportato.

Parse(Type, String)

Source:

Enum.cs

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente.

public:
 static System::Object ^ Parse(Type ^ enumType, System::String ^ value);

public static object Parse (Type enumType, string value);

static member Parse : Type * string -> obj

Public Shared Function Parse (enumType As Type, value As String) As Object

Parametri

enumType

Type

Tipo di enumerazione.

value

String

Stringa che contiene il nome o il valore da convertire.

Restituisce

Object

Oggetto di tipo enumType il cui valore è rappresentato da value.

Eccezioni

ArgumentNullException

enumType o value è null.

ArgumentException

enumType non è un elemento Enum.

-oppure-

value è una stringa vuota o contiene solo spazi vuoti.

-oppure-

value è un nome, ma non una delle costanti denominate definite per l'enumerazione.

OverflowException

value non è compreso nell'intervallo del tipo sottostante di enumType.

InvalidOperationException

.NET 8 e versioni successive: enumType è un tipo di enumerazione booleano supportato.

Esempio

Nell'esempio seguente viene usato il Parse(Type, String) metodo per analizzare una matrice di stringhe create chiamando il GetNames metodo . Usa anche il Parse(Type, String) metodo per analizzare un valore di enumerazione costituito da un campo bit.

using namespace System;

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

int main()
{
   Console::WriteLine(  "The entries of the Colors enumeration are:" );
   Array^ a = Enum::GetNames( Colors::typeid );
   Int32 i = 0;
   while ( i < a->Length )
   {
      Object^ o = a->GetValue( i );
      Console::WriteLine( o->ToString() );
      i++;
   }

   Console::WriteLine();
   Object^ orange = Enum::Parse( Colors::typeid,  "Red, Yellow" );
   Console::WriteLine("The orange value has the combined entries of {0}", orange );
}

/*
This code example produces the following results:

The entries of the Colors Enum are:
Red
Green
Blue
Yellow

The orange value has the combined entries of Red, Yellow

*/

using System;

public class ParseTest
{
    [Flags]
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static void Main()
    {
        Console.WriteLine("The entries of the Colors enumeration are:");
        foreach (string colorName in Enum.GetNames(typeof(Colors)))
        {
            Console.WriteLine("{0} = {1:D}", colorName,
                                         Enum.Parse(typeof(Colors), colorName));
        }
        Console.WriteLine();

        Colors orange = (Colors) Enum.Parse(typeof(Colors), "Red, Yellow");
        Console.WriteLine("The orange value {0:D} has the combined entries of {0}",
                           orange);
    }
}

/*
This code example produces the following results:

The entries of the Colors Enum are:
Red = 1
Green = 2
Blue = 4
Yellow = 8

The orange value 9 has the combined entries of Red, Yellow

*/

open System

[<Flags>]
type Colors =
    | Red = 1
    | Green = 2
    | Blue = 4
    | Yellow = 8

printfn "The entries of the Colors enumeration are:"
for colorName in Enum.GetNames typeof<Colors> do
    printfn $"{colorName} = {Enum.Parse(typeof<Colors>, colorName):D}"
printfn ""

let orange = Enum.Parse(typeof<Colors>, "Red, Yellow") :?> Colors
printfn $"The orange value {orange:D} has the combined entries of {orange}"

// This code example produces the following results:
//     The entries of the Colors Enum are:
//     Red = 1
//     Green = 2
//     Blue = 4
//     Yellow = 8
//    
//     The orange value 9 has the combined entries of Red, Yellow

Public Class ParseTest

    <Flags()> _
    Enum Colors
        Red = 1
        Green = 2
        Blue = 4
        Yellow = 8
    End Enum

    Public Shared Sub Main()
        Console.WriteLine("The entries of the Colors enumeration are:")
        Dim colorName As String
        For Each colorName In [Enum].GetNames(GetType(Colors))
            Console.WriteLine("{0} = {1:D}", colorName, [Enum].Parse(GetType(Colors), colorName))
        Next
        Console.WriteLine()

        Dim orange As Colors = CType([Enum].Parse(GetType(Colors), "Red, Yellow"), Colors)
        Console.WriteLine("The orange value {0:D} has the combined entries of {0}", orange)
    End Sub
End Class

'This example displays the following output:
'
'The entries of the Colors Enum are:
'Red = 1
'Green = 2
'Blue = 4
'Yellow = 8
'
'The myOrange value 9 has the combined entries of Red, Yellow
'

Commenti

Il value parametro contiene la rappresentazione stringa del valore sottostante di un membro di enumerazione o una costante denominata o un elenco di costanti denominate delimitate da virgole (,). Uno o più spazi vuoti possono precedere o seguire ogni valore, nome o virgola in value. Se value è un elenco, il valore restituito è il valore dei nomi specificati combinati con un'operazione bit per OR bit.

Se value è un nome che non corrisponde a una costante denominata di enumType, il metodo genera un ArgumentExceptionoggetto . Se value è la rappresentazione stringa di un intero che non rappresenta un valore sottostante dell'enumerazione enumType , il metodo restituisce un membro di enumerazione il cui valore sottostante viene value convertito in un tipo integrale. Se questo comportamento è indesiderato, chiamare il IsDefined metodo per assicurarsi che una rappresentazione di stringa specifica di un intero sia effettivamente un membro di enumType. Nell'esempio seguente viene definita un'enumerazione Colors , viene chiamato il metodo per convertire le stringhe nei valori di enumerazione corrispondenti e chiama il Parse(Type, String)IsDefined metodo per garantire che i valori integrali specifici siano valori sottostanti nell'enumerazione Colors .

using System;

[Flags] enum Colors { None=0, Red = 1, Green = 2, Blue = 4 };

public class Example
{
   public static void Main()
   {
      string[] colorStrings = { "0", "2", "8", "blue", "Blue", "Yellow", "Red, Green" };
      foreach (string colorString in colorStrings)
      {
         try {
            Colors colorValue = (Colors) Enum.Parse(typeof(Colors), colorString);
            if (Enum.IsDefined(typeof(Colors), colorValue) | colorValue.ToString().Contains(","))
               Console.WriteLine("Converted '{0}' to {1}.", colorString, colorValue.ToString());
            else
               Console.WriteLine("{0} is not an underlying value of the Colors enumeration.", colorString);
         }
         catch (ArgumentException) {
            Console.WriteLine("'{0}' is not a member of the Colors enumeration.", colorString);
         }
      }
   }
}
// The example displays the following output:
//       Converted '0' to None.
//       Converted '2' to Green.
//       8 is not an underlying value of the Colors enumeration.
//       'blue' is not a member of the Colors enumeration.
//       Converted 'Blue' to Blue.
//       'Yellow' is not a member of the Colors enumeration.
//       Converted 'Red, Green' to Red, Green.

open System

[<Flags>]
type Colors =
    | None = 0
    | Red = 1
    | Green = 2
    | Blue = 4

let colorStrings = [ "0"; "2"; "8"; "blue"; "Blue"; "Yellow"; "Red, Green" ]
for colorString in colorStrings do
    try
        let colorValue = Enum.Parse(typeof<Colors>, colorString) :?> Colors
        if Enum.IsDefined(typeof<Colors>, colorValue) || (string colorValue).Contains "," then
            printfn $"Converted '{colorString}' to {colorValue}."
        else
            printfn $"{colorString} is not an underlying value of the Colors enumeration."
    with :? ArgumentException ->
        printfn $"'{colorString}' is not a member of the Colors enumeration."
// The example displays the following output:
//       Converted '0' to None.
//       Converted '2' to Green.
//       8 is not an underlying value of the Colors enumeration.
//       'blue' is not a member of the Colors enumeration.
//       Converted 'Blue' to Blue.
//       'Yellow' is not a member of the Colors enumeration.
//       Converted 'Red, Green' to Red, Green.

<Flags> Enum Colors As Integer
   None = 0
   Red = 1
   Green = 2
   Blue = 4
End Enum

Module Example
   Public Sub Main()
      Dim colorStrings() As String = {"0", "2", "8", "blue", "Blue", "Yellow", "Red, Green"}
      For Each colorString As String In colorStrings
         Try
            Dim colorValue As Colors = CType([Enum].Parse(GetType(Colors), colorString), Colors)        
            If [Enum].IsDefined(GetType(Colors), colorValue) Or colorValue.ToString().Contains(",") Then 
               Console.WriteLine("Converted '{0}' to {1}.", colorString, colorValue.ToString())
            Else
               Console.WriteLine("{0} is not an underlying value of the Colors enumeration.", colorString)            
            End If                    
         Catch e As ArgumentException
            Console.WriteLine("'{0}' is not a member of the Colors enumeration.", colorString)
         End Try
      Next
   End Sub
End Module
' The example displays the following output:
'       Converted '0' to None.
'       Converted '2' to Green.
'       8 is not an underlying value of the Colors enumeration.
'       'blue' is not a member of the Colors enumeration.
'       Converted 'Blue' to Blue.
'       'Yellow' is not a member of the Colors enumeration.
'       Converted 'Red, Green' to Red, Green.

Questa operazione è distinzione tra maiuscole e minuscole.

Vedi anche

• IsDefined(Type, Object)

Parse(Type, ReadOnlySpan<Char>, Boolean)

Source:

Enum.cs

Converte l'intervallo di rappresentazione di caratteri del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.

public:
 static System::Object ^ Parse(Type ^ enumType, ReadOnlySpan<char> value, bool ignoreCase);

public static object Parse (Type enumType, ReadOnlySpan<char> value, bool ignoreCase);

static member Parse : Type * ReadOnlySpan<char> * bool -> obj

Public Shared Function Parse (enumType As Type, value As ReadOnlySpan(Of Char), ignoreCase As Boolean) As Object

Parametri

enumType

Type

Tipo di enumerazione.

value

ReadOnlySpan<Char>

Intervallo contenente il nome o il valore da convertire.

ignoreCase

Boolean

true per ignorare la distinzione tra maiuscole e minuscole; in caso contrario, false.

Restituisce

Object

Oggetto di tipo enumType il cui valore è rappresentato da value.

Eccezioni

ArgumentNullException

enumType è null.

ArgumentException

enumType non è un elemento Enum.

ArgumentException

value è una stringa vuota o contiene solo spazi vuoti.

ArgumentException

value è un nome, ma non una delle costanti denominate definite per l'enumerazione.

OverflowException

value non è compreso nell'intervallo del tipo sottostante di enumType

InvalidOperationException

.NET 8 e versioni successive: enumType è un tipo di enumerazione booleano supportato.

Parse(Type, String, Boolean)

Source:

Enum.cs

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.

public:
 static System::Object ^ Parse(Type ^ enumType, System::String ^ value, bool ignoreCase);

public static object Parse (Type enumType, string value, bool ignoreCase);

static member Parse : Type * string * bool -> obj

Public Shared Function Parse (enumType As Type, value As String, ignoreCase As Boolean) As Object

Parametri

enumType

Type

Tipo di enumerazione.

value

String

Stringa che contiene il nome o il valore da convertire.

ignoreCase

Boolean

true per ignorare la distinzione tra maiuscole e minuscole; in caso contrario, false.

Restituisce

Object

Oggetto di tipo enumType il cui valore è rappresentato da value.

Eccezioni

ArgumentNullException

enumType o value è null.

ArgumentException

enumType non è un elemento Enum.

-oppure-

value è una stringa vuota ("") o contiene solo spazi vuoti.

-oppure-

value è un nome, ma non una delle costanti denominate definite per l'enumerazione.

OverflowException

value non è compreso nell'intervallo del tipo sottostante di enumType.

InvalidOperationException

.NET 8 e versioni successive: enumType è un tipo di enumerazione booleano supportato.

Esempio

Nell'esempio seguente viene usato il Parse(Type, String, Boolean) metodo per analizzare una matrice di stringhe create chiamando il GetNames metodo . Usa anche il Parse(Type, String) metodo per analizzare un valore di enumerazione costituito da un campo bit.

using System;

[Flags] enum Colors { None=0, Red = 1, Green = 2, Blue = 4 };

public class Example
{
   public static void Main()
   {
      string[] colorStrings = { "0", "2", "8", "blue", "Blue", "Yellow", "Red, Green" };
      foreach (string colorString in colorStrings)
      {
         try {
            Colors colorValue = (Colors) Enum.Parse(typeof(Colors), colorString, true);
            if (Enum.IsDefined(typeof(Colors), colorValue) | colorValue.ToString().Contains(","))
               Console.WriteLine("Converted '{0}' to {1}.", colorString, colorValue.ToString());
            else
               Console.WriteLine("{0} is not an underlying value of the Colors enumeration.", colorString);
         }
         catch (ArgumentException) {
            Console.WriteLine("{0} is not a member of the Colors enumeration.", colorString);
         }
      }
   }
}
// The example displays the following output:
//       Converted '0' to None.
//       Converted '2' to Green.
//       8 is not an underlying value of the Colors enumeration.
//       Converted 'blue' to Blue.
//       Converted 'Blue' to Blue.
//       Yellow is not a member of the Colors enumeration.
//       Converted 'Red, Green' to Red, Green.

open System

[<Flags>]
type Colors =
    | None = 0
    | Red = 1
    | Green = 2
    | Blue = 4

let colorStrings = [ "0"; "2"; "8"; "blue"; "Blue"; "Yellow"; "Red, Green" ]
for colorString in colorStrings do
    try
        let colorValue = Enum.Parse(typeof<Colors>, colorString, true) :?> Colors
        if Enum.IsDefined(typeof<Colors>, colorValue) || (string colorValue).Contains "," then
            printfn $"Converted '{colorString}' to {colorValue}."
        else
            printfn $"{colorString} is not an underlying value of the Colors enumeration."
    with :? ArgumentException ->
        printfn $"{colorString} is not a member of the Colors enumeration."

// The example displays the following output:
//       Converted '0' to None.
//       Converted '2' to Green.
//       8 is not an underlying value of the Colors enumeration.
//       Converted 'blue' to Blue.
//       Converted 'Blue' to Blue.
//       Yellow is not a member of the Colors enumeration.
//       Converted 'Red, Green' to Red, Green.

<Flags> Enum Colors As Integer
   None = 0
   Red = 1
   Green = 2
   Blue = 4
End Enum

Module Example
   Public Sub Main()
      Dim colorStrings() As String = {"0", "2", "8", "blue", "Blue", "Yellow", "Red, Green"}
      For Each colorString As String In colorStrings
         Try
            Dim colorValue As Colors = CType([Enum].Parse(GetType(Colors), colorString, True), Colors)        
            If [Enum].IsDefined(GetType(Colors), colorValue) Or colorValue.ToString().Contains(",") Then 
               Console.WriteLine("Converted '{0}' to {1}.", colorString, colorValue.ToString())
            Else
               Console.WriteLine("{0} is not an underlying value of the Colors enumeration.", colorString)            
            End If                    
         Catch e As ArgumentException
            Console.WriteLine("{0} is not a member of the Colors enumeration.", colorString)
         End Try
      Next
   End Sub
End Module
' The example displays the following output:
'       Converted '0' to None.
'       Converted '2' to Green.
'       8 is not an underlying value of the Colors enumeration.
'       Converted 'blue' to Blue.
'       Converted 'Blue' to Blue.
'       Yellow is not a member of the Colors enumeration.
'       Converted 'Red, Green' to Red, Green.

Commenti

Il value parametro contiene la rappresentazione stringa del valore sottostante di un membro di enumerazione o una costante denominata o un elenco di costanti denominate delimitate da virgole (,). Uno o più spazi vuoti possono precedere o seguire ogni valore, nome o virgola in value. Se value è un elenco, il valore restituito è il valore dei nomi specificati combinati con un'operazione bit per OR bit.

Se value è un nome che non corrisponde a una costante denominata di enumType, il metodo genera un ArgumentExceptionoggetto . Se value è la rappresentazione stringa di un intero che non rappresenta un valore sottostante dell'enumerazione enumType , il metodo restituisce un membro di enumerazione il cui valore sottostante viene value convertito in un tipo integrale. Se questo comportamento è indesiderato, chiamare il IsDefined metodo per assicurarsi che una rappresentazione di stringa specifica di un intero sia effettivamente un membro di enumType. Nell'esempio seguente viene definita un'enumerazione Colors , viene chiamato il metodo per convertire le stringhe nei valori di enumerazione corrispondenti e chiama il Parse(Type, String, Boolean)IsDefined metodo per garantire che i valori integrali specifici siano valori sottostanti nell'enumerazione Colors .

Il ignoreCase parametro specifica se questa operazione è distinzione tra maiuscole e minuscole.

Vedi anche

• IsDefined(Type, Object)

Parse<TEnum>(String, Boolean)

Source:

Enum.cs

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate specificate da TEnumin un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.

public:
generic <typename TEnum>
 where TEnum : value class static TEnum Parse(System::String ^ value, bool ignoreCase);

public static TEnum Parse<TEnum> (string value, bool ignoreCase) where TEnum : struct;

static member Parse : string * bool -> 'Enum (requires 'Enum : struct)

Public Shared Function Parse(Of TEnum As Structure) (value As String, ignoreCase As Boolean) As TEnum

Parametri di tipo

TEnum

Tipo di enumerazione.

Parametri

value

String

Stringa che contiene il nome o il valore da convertire.

ignoreCase

Boolean

true per ignorare la distinzione tra maiuscole e minuscole; in caso contrario, false.

Restituisce

TEnum

Oggetto di tipo TEnum il cui valore è rappresentato da value.

Eccezioni

ArgumentException

TEnum non è un tipo Enum.

ArgumentNullException

value è null.

ArgumentException

value non contiene informazioni sull'enumerazione.

InvalidOperationException

.NET 8 e versioni successive: TEnum è un tipo di enumerazione booleano supportato.

Parse<TEnum>(ReadOnlySpan<Char>, Boolean)

Source:

Enum.cs

Converte l'intervallo di rappresentazioni di caratteri del nome o del valore numerico di una o più costanti enumerate specificate da TEnum in un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.

public:
generic <typename TEnum>
 where TEnum : value class static TEnum Parse(ReadOnlySpan<char> value, bool ignoreCase);

public static TEnum Parse<TEnum> (ReadOnlySpan<char> value, bool ignoreCase) where TEnum : struct;

static member Parse : ReadOnlySpan<char> * bool -> 'Enum (requires 'Enum : struct)

Public Shared Function Parse(Of TEnum As Structure) (value As ReadOnlySpan(Of Char), ignoreCase As Boolean) As TEnum

Parametri di tipo

TEnum

Tipo di enumerazione.

Parametri

value

ReadOnlySpan<Char>

Intervallo contenente il nome o il valore da convertire.

ignoreCase

Boolean

true per ignorare la distinzione tra maiuscole e minuscole; in caso contrario, false.

Restituisce

TEnum

TEnum Oggetto di tipo TEnum il cui valore è rappresentato da value.

Eccezioni

ArgumentException

TEnum non è un tipo Enum.

ArgumentException

value non contiene informazioni sull'enumerazione.

InvalidOperationException

.NET 8 e versioni successive: TEnum è un tipo di enumerazione con supporto booleano.

Parse<TEnum>(ReadOnlySpan<Char>)

Source:

Enum.cs

Converte l'intervallo di rappresentazioni di caratteri del nome o del valore numerico di una o più costanti enumerate specificate da TEnum in un oggetto enumerato equivalente.

public:
generic <typename TEnum>
 where TEnum : value class static TEnum Parse(ReadOnlySpan<char> value);

public static TEnum Parse<TEnum> (ReadOnlySpan<char> value) where TEnum : struct;

static member Parse : ReadOnlySpan<char> -> 'Enum (requires 'Enum : struct)

Public Shared Function Parse(Of TEnum As Structure) (value As ReadOnlySpan(Of Char)) As TEnum

Parametri di tipo

TEnum

Tipo di enumerazione.

Parametri

value

ReadOnlySpan<Char>

Intervallo contenente il nome o il valore da convertire.

Restituisce

TEnum

TEnum Oggetto di tipo TEnum il cui valore è rappresentato da value.

Eccezioni

ArgumentException

TEnum non è un tipo Enum.

ArgumentException

value non contiene informazioni sull'enumerazione.

InvalidOperationException

.NET 8 e versioni successive: TEnum è un tipo di enumerazione con supporto booleano.

Parse<TEnum>(String)

Source:

Enum.cs

Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate specificate da TEnumin un oggetto enumerato equivalente.

public:
generic <typename TEnum>
 where TEnum : value class static TEnum Parse(System::String ^ value);

public static TEnum Parse<TEnum> (string value) where TEnum : struct;

static member Parse : string -> 'Enum (requires 'Enum : struct)

Public Shared Function Parse(Of TEnum As Structure) (value As String) As TEnum

Parametri di tipo

TEnum

Tipo di enumerazione.

Parametri

value

String

Stringa che contiene il nome o il valore da convertire.

Restituisce

TEnum

Oggetto di tipo TEnum il cui valore è rappresentato da value.

Eccezioni

ArgumentException

TEnum non è un tipo Enum.

ArgumentNullException

value è null.

ArgumentException

value non contiene informazioni sull'enumerazione.

InvalidOperationException

.NET 8 e versioni successive: TEnum è un tipo di enumerazione con supporto booleano.