Condividi tramite

Enum.Parse Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.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 caratteri di rappresentazione 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 caratteri di rappresentazione del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente. Un parametro specifica se l'operazione non fa 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 non fa 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 TEnum in un oggetto enumerato equivalente. Un parametro specifica se l'operazione non fa 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 non fa 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 TEnum in un oggetto enumerato equivalente.

Parse(Type, ReadOnlySpan<Char>)

Origine:
Enum.cs
Origine:
Enum.cs
Origine:
Enum.cs

Converte l'intervallo di caratteri di rappresentazione 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 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 rientra nell'intervallo del tipo sottostante di enumType.

InvalidOperationException

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

Si applica a

Parse(Type, String)

Origine:
Enum.cs
Origine:
Enum.cs
Origine:
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);
[System.Runtime.InteropServices.ComVisible(true)]
public static object Parse (Type enumType, string value);
static member Parse : Type * string -> obj
[<System.Runtime.InteropServices.ComVisible(true)>]
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 contenente il nome o il valore da convertire.

Restituisce

Object

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

Attributi
ComVisibleAttribute

Eccezioni

ArgumentNullException

enumType o value è null.

ArgumentException

enumType non è un Enum.

-o-

value è una stringa vuota o contiene solo spazi vuoti.

-o-

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

OverflowException

value non rientra nell'intervallo del tipo sottostante di enumType.

InvalidOperationException

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

Esempio

Nell'esempio seguente viene utilizzato il metodo Parse(Type, String) per analizzare una matrice di stringhe create chiamando il metodo GetNames. Usa anche il metodo Parse(Type, String) per analizzare un valore di enumerazione costituito da un campo di 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 parametro value contiene la rappresentazione di stringa del valore sottostante o della costante denominata di un membro di enumerazione oppure 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 di OR bit per bit.

Se value è un nome che non corrisponde a una costante denominata di enumType, il metodo genera un ArgumentException. Se value è la rappresentazione di stringa di un numero intero che non rappresenta un valore sottostante dell'enumerazione enumType, il metodo restituisce un membro di enumerazione il cui valore sottostante è value convertito in un tipo integrale. Se questo comportamento è indesiderato, chiamare il metodo IsDefined per assicurarsi che una determinata rappresentazione di stringa di un numero intero sia effettivamente un membro di enumType. Nell'esempio seguente viene definita un'enumerazione Colors, viene chiamato il metodo Parse(Type, String) per convertire le stringhe nei valori di enumerazione corrispondenti e viene chiamato il metodo IsDefined per assicurarsi che determinati valori integrali 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 fa distinzione tra maiuscole e minuscole.

Vedi anche

Si applica a

Parse(Type, ReadOnlySpan<Char>, Boolean)

Origine:
Enum.cs
Origine:
Enum.cs
Origine:
Enum.cs

Converte l'intervallo di caratteri di rappresentazione del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente. Un parametro specifica se l'operazione non fa 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 ignorare la distinzione tra maiuscole e minuscole; false di considerare il caso.

Restituisce

Object

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

Eccezioni

ArgumentNullException

enumType è null.

ArgumentException

enumType non è un 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 rientra nell'intervallo del tipo sottostante di enumType

InvalidOperationException

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

Si applica a

Parse(Type, String, Boolean)

Origine:
Enum.cs
Origine:
Enum.cs
Origine:
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 non fa 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);
[System.Runtime.InteropServices.ComVisible(true)]
public static object Parse (Type enumType, string value, bool ignoreCase);
static member Parse : Type * string * bool -> obj
[<System.Runtime.InteropServices.ComVisible(true)>]
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 contenente il nome o il valore da convertire.

ignoreCase
Boolean

true ignorare la distinzione tra maiuscole e minuscole; false di considerare il caso.

Restituisce

Object

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

Attributi
ComVisibleAttribute

Eccezioni

ArgumentNullException

enumType o value è null.

ArgumentException

enumType non è un Enum.

-o-

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

-o-

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

OverflowException

value non rientra nell'intervallo del tipo sottostante di enumType.

InvalidOperationException

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

Esempio

Nell'esempio seguente viene utilizzato il metodo Parse(Type, String, Boolean) per analizzare una matrice di stringhe create chiamando il metodo GetNames. Usa anche il metodo Parse(Type, String) per analizzare un valore di enumerazione costituito da un campo di 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 parametro value contiene la rappresentazione di stringa del valore sottostante o della costante denominata di un membro di enumerazione oppure 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 di OR bit per bit.

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

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

Vedi anche

Si applica a

Parse<TEnum>(String, Boolean)

Origine:
Enum.cs
Origine:
Enum.cs
Origine:
Enum.cs

Converte la rappresentazione di stringa 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 non fa 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 contenente il nome o il valore da convertire.

ignoreCase
Boolean

true ignorare la distinzione tra maiuscole e minuscole; false di considerare il caso.

Restituisce

TEnum

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

Eccezioni

ArgumentException

TEnum non è un tipo di Enum.

ArgumentNullException

value è null.

ArgumentException

value non contiene informazioni sull'enumerazione.

InvalidOperationException

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

Si applica a

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

Origine:
Enum.cs
Origine:
Enum.cs
Origine:
Enum.cs

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 non fa 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 ignorare la distinzione tra maiuscole e minuscole; false di considerare il caso.

Restituisce

TEnum

TEnum Un oggetto di tipo TEnum il cui valore è rappresentato da value.

Eccezioni

ArgumentException

TEnum non è un tipo di Enum.

ArgumentException

value non contiene informazioni sull'enumerazione.

InvalidOperationException

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

Si applica a

Parse<TEnum>(ReadOnlySpan<Char>)

Origine:
Enum.cs
Origine:
Enum.cs
Origine:
Enum.cs

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.

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 Un oggetto di tipo TEnum il cui valore è rappresentato da value.

Eccezioni

ArgumentException

TEnum non è un tipo di Enum.

ArgumentException

value non contiene informazioni sull'enumerazione.

InvalidOperationException

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

Si applica a

Parse<TEnum>(String)

Origine:
Enum.cs
Origine:
Enum.cs
Origine:
Enum.cs

Converte la rappresentazione di stringa 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(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 contenente 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 di Enum.

ArgumentNullException

value è null.

ArgumentException

value non contiene informazioni sull'enumerazione.

InvalidOperationException

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

Si applica a