Enum.TryParse Méthode

Référence

Définition

Espace de noms:: System

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assemblys:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent. La valeur de retour indique si la conversion a réussi.

Surcharges

TryParse(Type, ReadOnlySpan<Char>, Object)	Convertit l’étendue des caractères représentant le nom ou la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent.
TryParse(Type, String, Object)	Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent.
TryParse(Type, ReadOnlySpan<Char>, Boolean, Object)	Convertit l’étendue des caractères représentant le nom ou la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent. Un paramètre spécifie si l’opération ne respecte pas la casse.
TryParse(Type, String, Boolean, Object)	Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent.
TryParse<TEnum>(ReadOnlySpan<Char>, TEnum)	Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent.
TryParse<TEnum>(String, TEnum)	Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent. La valeur de retour indique si la conversion a réussi.
TryParse<TEnum>(String, Boolean, TEnum)	Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent. Un paramètre spécifie si l’opération respecte la casse. La valeur de retour indique si la conversion a réussi.
TryParse<TEnum>(ReadOnlySpan<Char>, Boolean, TEnum)	Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent. Un paramètre spécifie si l’opération respecte la casse. La valeur de retour indique si la conversion a réussi.

TryParse(Type, ReadOnlySpan<Char>, Object)

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Convertit l’étendue des caractères représentant le nom ou la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent.

public:
 static bool TryParse(Type ^ enumType, ReadOnlySpan<char> value, [Runtime::InteropServices::Out] System::Object ^ % result);

public static bool TryParse(Type enumType, ReadOnlySpan<char> value, out object? result);

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

Public Shared Function TryParse (enumType As Type, value As ReadOnlySpan(Of Char), ByRef result As Object) As Boolean

Paramètres

enumType: Type

Type d’énumération à utiliser pour l’analyse.

value: ReadOnlySpan<Char>

Représentation d’étendue du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées.

result: Object

Lorsque cette méthode retourne true, contient une constante d’énumération qui représente la valeur analysée.

Retours

Boolean

true si la conversion a réussi ; false sinon.

Exceptions

InvalidOperationException

.NET 8 et versions ultérieures : enumType est un type d’énumération booléen.

S’applique à

TryParse(Type, String, Object)

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent.

public:
 static bool TryParse(Type ^ enumType, System::String ^ value, [Runtime::InteropServices::Out] System::Object ^ % result);

public static bool TryParse(Type enumType, string? value, out object? result);

public static bool TryParse(Type enumType, string value, out object result);

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

Public Shared Function TryParse (enumType As Type, value As String, ByRef result As Object) As Boolean

Paramètres

enumType: Type

Type d’énumération à utiliser pour l’analyse.

value: String

Représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées.

result: Object

Lorsque cette méthode retourne true, contient une constante d’énumération qui représente la valeur analysée.

Retours

Boolean

true si la conversion a réussi ; false sinon.

Exceptions

InvalidOperationException

.NET 8 et versions ultérieures : enumType est un type d’énumération booléen.

S’applique à

TryParse(Type, ReadOnlySpan<Char>, Boolean, Object)

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Convertit l’étendue des caractères représentant le nom ou la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent. Un paramètre spécifie si l’opération ne respecte pas la casse.

public:
 static bool TryParse(Type ^ enumType, ReadOnlySpan<char> value, bool ignoreCase, [Runtime::InteropServices::Out] System::Object ^ % result);

public static bool TryParse(Type enumType, ReadOnlySpan<char> value, bool ignoreCase, out object? result);

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

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

Paramètres

enumType: Type

Type d’énumération à utiliser pour l’analyse.

value: ReadOnlySpan<Char>

Représentation d’étendue du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées.

ignoreCase: Boolean

true lire enumType en mode insensible à la casse ; false lire enumType en mode respectant la casse.

result: Object

Lorsque cette méthode retourne true, contient une constante d’énumération qui représente la valeur analysée.

Retours

Boolean

true si la conversion a réussi ; false sinon.

Exceptions

InvalidOperationException

.NET 8 et versions ultérieures : enumType est un type d’énumération booléen.

S’applique à

TryParse(Type, String, Boolean, Object)

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent.

public:
 static bool TryParse(Type ^ enumType, System::String ^ value, bool ignoreCase, [Runtime::InteropServices::Out] System::Object ^ % result);

public static bool TryParse(Type enumType, string? value, bool ignoreCase, out object? result);

public static bool TryParse(Type enumType, string value, bool ignoreCase, out object result);

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

Public Shared Function TryParse (enumType As Type, value As String, ignoreCase As Boolean, ByRef result As Object) As Boolean

Paramètres

enumType: Type

Type d’énumération à utiliser pour l’analyse.

value: String

Représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées.

ignoreCase: Boolean

true lire value en mode insensible à la casse ; false lire value en mode respectant la casse.

result: Object

Lorsque cette méthode retourne true, contient une constante d’énumération qui représente la valeur analysée.

Retours

Boolean

true si la conversion a réussi ; false sinon.

Exceptions

InvalidOperationException

.NET 8 et versions ultérieures : enumType est un type d’énumération booléen.

S’applique à

TryParse<TEnum>(ReadOnlySpan<Char>, TEnum)

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent.

public:
generic <typename TEnum>
 where TEnum : value class static bool TryParse(ReadOnlySpan<char> value, [Runtime::InteropServices::Out] TEnum % result);

public static bool TryParse<TEnum>(ReadOnlySpan<char> value, out TEnum result) where TEnum : struct;

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

Public Shared Function TryParse(Of TEnum As Structure) (value As ReadOnlySpan(Of Char), ByRef result As TEnum) As Boolean

Paramètres de type

TEnum

Type de l’objet result.

Paramètres

value: ReadOnlySpan<Char>

Représentation d’étendue du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées.

result: TEnum

Lorsque cette méthode retourne true, contient une constante d’énumération qui représente la valeur analysée.

Retours

Boolean

true si la conversion a réussi ; false sinon.

Exceptions

ArgumentException

TEnum n’est pas un type d’énumération.

InvalidOperationException

.NET 8 et versions ultérieures : TEnum est un type d’énumération booléen.

S’applique à

TryParse<TEnum>(String, TEnum)

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

public:
generic <typename TEnum>
 where TEnum : value class static bool TryParse(System::String ^ value, [Runtime::InteropServices::Out] TEnum % result);

public static bool TryParse<TEnum>(string value, out TEnum result) where TEnum : struct;

public static bool TryParse<TEnum>(string? value, out TEnum result) where TEnum : struct;

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

Public Shared Function TryParse(Of TEnum As Structure) (value As String, ByRef result As TEnum) As Boolean

Paramètres de type

TEnum

Type d’énumération vers lequel convertir value.

Paramètres

value: String

Représentation sous-jacente de chaîne sensible à la casse du nom d’énumération ou de la valeur sous-jacente à convertir.

result: TEnum

Lorsque cette méthode est retournée, contient un objet de type TEnum dont la valeur est représentée par value si l’opération d’analyse réussit. Si l’opération d’analyse échoue, contient la valeur par défaut du type sous-jacent de TEnum. Ce paramètre est passé non initialisé.

Retours

Boolean

true si le paramètre value a été converti correctement ; sinon, false.

Exceptions

ArgumentException

TEnum n’est pas un type d’énumération.

InvalidOperationException

.NET 8 et versions ultérieures : TEnum est un type d’énumération booléen.

Exemples

L’exemple suivant définit une énumération Colors, appelle la méthode TryParse<TEnum>(String, TEnum) pour convertir des chaînes en leurs valeurs d’énumération correspondantes et appelle la méthode IsDefined pour s’assurer que les valeurs intégrales particulières sont des valeurs sous-jacentes dans l’énumération 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)
      {
         Colors colorValue;
         if (Enum.TryParse(colorString, out colorValue))
            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);
         else
            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
    match Enum.TryParse colorString with
    | true, colorValue ->
        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."
    | _ ->
        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
         Dim colorValue As Colors
         If [Enum].TryParse(colorString, colorValue) Then        
            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                    
         Else
            Console.WriteLine("{0} is not a member of the Colors enumeration.", colorString)
         End If
      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.

Remarques

TryParse<TEnum>(String, TEnum) est identique à la méthode Parse(Type, String), sauf qu’au lieu de lever une exception, elle retourne false si la conversion échoue. Elle élimine la nécessité de gérer les exceptions lors de l’analyse de la représentation sous forme de chaîne d’une valeur d’énumération.

Le paramètre value contient la représentation sous-jacente d’un membre d’énumération ou d’une constante nommée, ou une liste de constantes nommées ou des valeurs sous-jacentes délimitées par des virgules (,). Si value inclut plusieurs constantes ou valeurs nommées, un ou plusieurs espaces vides peuvent précéder ou suivre chaque valeur, nom ou virgule dans value. Si value est une liste, result reflète la valeur des noms spécifiés ou des valeurs sous-jacentes combinées à une opération de OR au niveau du bit. Si value est la représentation sous forme de chaîne du nom d’une valeur d’énumération, la comparaison de value avec les noms d’énumération respecte la casse.

Si value est un nom qui ne correspond pas à une constante nommée de TEnum, la méthode retourne false. Si value est la représentation sous-jacente d’un entier qui ne représente pas une valeur sous-jacente de l’énumération TEnum, la méthode retourne un membre d’énumération dont la valeur sous-jacente est value convertie en type intégral. Si ce comportement n’est pas souhaitable, appelez la méthode IsDefined pour vous assurer qu’une représentation sous forme de chaîne particulière d’un entier est en fait membre de TEnum.

Si l’opération d’analyse échoue, le paramètre result contient la valeur par défaut 0, qui peut ne pas être membre de l’énumération TEnum sous-jacente. Si aucune valeur n’est affectée aux constantes nommées dans TEnum, la valeur par défaut est égale au premier membre du TEnum. Sinon, la valeur par défaut est égale au membre de l’énumération avec une valeur affectée de 0.

Voir aussi

Parse(Type, String)

S’applique à

TryParse<TEnum>(String, Boolean, TEnum)

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées en objet énuméré équivalent. Un paramètre spécifie si l’opération respecte la casse. La valeur de retour indique si la conversion a réussi.

public:
generic <typename TEnum>
 where TEnum : value class static bool TryParse(System::String ^ value, bool ignoreCase, [Runtime::InteropServices::Out] TEnum % result);

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

public static bool TryParse<TEnum>(string? value, bool ignoreCase, out TEnum result) where TEnum : struct;

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

Public Shared Function TryParse(Of TEnum As Structure) (value As String, ignoreCase As Boolean, ByRef result As TEnum) As Boolean

Paramètres de type

TEnum

Type d’énumération vers lequel convertir value.

Paramètres

value: String

Représentation sous-jacente du nom d’énumération ou de la valeur sous-jacente à convertir.

ignoreCase: Boolean

true pour ignorer la casse ; false prendre en compte le cas.

result: TEnum

Retours

Boolean

true si le paramètre value a été converti correctement ; sinon, false.

Exceptions

ArgumentException

TEnum n’est pas un type d’énumération.

InvalidOperationException

.NET 8 et versions ultérieures : TEnum est un type d’énumération booléen.

Exemples

L’exemple suivant définit une énumération Colors, appelle la méthode TryParse<TEnum>(String, Boolean, TEnum) pour convertir des chaînes en leurs valeurs d’énumération correspondantes et appelle la méthode IsDefined pour s’assurer que les valeurs intégrales particulières sont des valeurs sous-jacentes dans l’énumération Colors. La méthode TryParse<TEnum>(String, Boolean, TEnum) utilise une comparaison sans respect de la casse lors de la tentative de conversion des représentations sous forme de chaîne de constantes nommées en leurs valeurs d’énumération équivalentes.

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)
      {
         Colors colorValue;
         if (Enum.TryParse(colorString, true, out colorValue))
            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);
         else
            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
    match Enum.TryParse(colorString, true) with
    | true, colorValue ->
        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."
    | _ ->
        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
         Dim colorValue As Colors
         If [Enum].TryParse(colorString, True, colorValue) Then        
            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                    
         Else
            Console.WriteLine("{0} is not a member of the Colors enumeration.", colorString)
         End If
      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.

Remarques

TryParse<TEnum>(String, Boolean, TEnum) est identique à la méthode Parse(Type, String, Boolean), sauf qu’au lieu de lever une exception, elle retourne false si la conversion échoue. Elle élimine la nécessité de gérer les exceptions lors de l’analyse de la représentation sous forme de chaîne d’une valeur d’énumération.

Voir aussi

Parse(Type, String, Boolean)

S’applique à

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

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

Source:: Enum.cs

public:
generic <typename TEnum>
 where TEnum : value class static bool TryParse(ReadOnlySpan<char> value, bool ignoreCase, [Runtime::InteropServices::Out] TEnum % result);

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

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

Public Shared Function TryParse(Of TEnum As Structure) (value As ReadOnlySpan(Of Char), ignoreCase As Boolean, ByRef result As TEnum) As Boolean

Paramètres de type

TEnum

Type de l’objet result.

Paramètres

value: ReadOnlySpan<Char>

Représentation d’étendue du nom ou de la valeur numérique d’une ou plusieurs constantes énumérées.

ignoreCase: Boolean

true pour ignorer la casse ; false prendre en compte le cas.

result: TEnum

Lorsque cette méthode retourne true, contient une constante d’énumération qui représente la valeur analysée.

Retours

Boolean

true si la conversion a réussi ; false sinon.

Exceptions

ArgumentException

TEnum n’est pas un type d’énumération.

InvalidOperationException

.NET 8 et versions ultérieures : TEnum est un type d’énumération booléen.

S’applique à

Rétroaction

Cette page vous a-t-elle été utile ?

Partager via

Enum.TryParse Méthode

Définition

Surcharges

TryParse(Type, ReadOnlySpan<Char>, Object)

Paramètres

Retours

Exceptions

S’applique à

TryParse(Type, String, Object)

Paramètres

Retours

Exceptions

S’applique à

TryParse(Type, ReadOnlySpan<Char>, Boolean, Object)

Paramètres

Retours

Exceptions

S’applique à

TryParse(Type, String, Boolean, Object)

Paramètres

Retours

Exceptions

S’applique à

TryParse<TEnum>(ReadOnlySpan<Char>, TEnum)

Paramètres de type

Paramètres

Retours

Exceptions

S’applique à

TryParse<TEnum>(String, TEnum)

Paramètres de type

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

TryParse<TEnum>(String, Boolean, TEnum)

Paramètres de type

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

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

Paramètres de type

Paramètres

Retours

Exceptions

S’applique à

Rétroaction