Enum.Parse Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
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 |
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 |
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 |
Parse<TEnum>(String) |
Converte la rappresentazione di stringa del nome o del valore numerico di una o più costanti enumerate specificate da |
Parse(Type, ReadOnlySpan<Char>)
- Origine:
- Enum.cs
- Origine:
- Enum.cs
- Origine:
- 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
Oggetto di tipo enumType
il cui valore è rappresentato da value
.
Eccezioni
enumType
è null
.
enumType
non è un elemento Enum.
value
è una stringa vuota o contiene solo spazi vuoti.
value
è un nome, ma non una delle costanti denominate definite per l'enumerazione.
value
non è compreso nell'intervallo del tipo sottostante di enumType
.
.NET 8 e versioni successive: enumType
è un tipo di enumerazione booleano supportato.
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 che contiene il nome o il valore da convertire.
Restituisce
Oggetto di tipo enumType
il cui valore è rappresentato da value
.
- Attributi
Eccezioni
enumType
o value
è null
.
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.
value
non è compreso nell'intervallo del tipo sottostante di enumType
.
.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
Si applica a
Parse(Type, ReadOnlySpan<Char>, Boolean)
- Origine:
- Enum.cs
- Origine:
- Enum.cs
- Origine:
- 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
Oggetto di tipo enumType
il cui valore è rappresentato da value
.
Eccezioni
enumType
è null
.
enumType
non è un elemento Enum.
value
è una stringa vuota o contiene solo spazi vuoti.
value
è un nome, ma non una delle costanti denominate definite per l'enumerazione.
value
non è compreso nell'intervallo del tipo sottostante di enumType
.NET 8 e versioni successive: enumType
è un tipo di enumerazione booleano supportato.
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 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);
[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 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
Oggetto di tipo enumType
il cui valore è rappresentato da value
.
- Attributi
Eccezioni
enumType
o value
è null
.
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.
value
non è compreso nell'intervallo del tipo sottostante di enumType
.
.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
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 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
Oggetto di tipo TEnum
il cui valore è rappresentato da value
.
Eccezioni
TEnum
non è un tipo Enum.
value
è null
.
value
non contiene informazioni sull'enumerazione.
.NET 8 e versioni successive: TEnum
è un tipo di enumerazione booleano supportato.
Si applica a
Parse<TEnum>(ReadOnlySpan<Char>, Boolean)
- Origine:
- Enum.cs
- Origine:
- Enum.cs
- Origine:
- 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
Oggetto di tipo TEnum
il cui valore è rappresentato da value
.
Eccezioni
TEnum
non è un tipo Enum.
value
non contiene informazioni sull'enumerazione.
.NET 8 e versioni successive: TEnum
è un tipo di enumerazione con supporto booleano.
Si applica a
Parse<TEnum>(ReadOnlySpan<Char>)
- Origine:
- Enum.cs
- Origine:
- Enum.cs
- Origine:
- 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
Oggetto di tipo TEnum
il cui valore è rappresentato da value
.
Eccezioni
TEnum
non è un tipo Enum.
value
non contiene informazioni sull'enumerazione.
.NET 8 e versioni successive: TEnum
è un tipo di enumerazione con supporto 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 che contiene il nome o il valore da convertire.
Restituisce
Oggetto di tipo TEnum
il cui valore è rappresentato da value
.
Eccezioni
TEnum
non è un tipo Enum.
value
è null
.
value
non contiene informazioni sull'enumerazione.
.NET 8 e versioni successive: TEnum
è un tipo di enumerazione con supporto booleano.
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per