with Come posso usare il valore stringa di un valore enum di C#in un'istruzione case?




java enumeration syntax (9)

Ho definito un enum di C # come

public enum ORDER
{
    ...
    unknown,
    partial01,
    partial12,
    partial23,
}

e può usare il suo valore come una stringa come in:

            string ss = ORDER.partial01.ToString();

Tuttavia, quando provo ad usarlo in un'istruzione case non riesce a compilare:

string value = ...
switch (value)
{
    case null:
        break;
    case "s":
        // OK
        break;
    case ORDER.partial01.ToString():
        // compiler throws "a constant value is expected"

        break;
  ...

Pensavo che le enumerazioni fossero costanti. Come faccio a evitare questo?

(Non riesco ad analizzare il valore in un enumer quando alcuni valori non rientrano nell'intervallo)


I valori Enum sono costanti, ma stai cercando di utilizzare i risultati di un metodo (ORDER.partial01.ToString ()), non una costante.

L'opzione migliore, a mio avviso, sarebbe quella di passare semplicemente all'utilizzo delle istruzioni if ​​/ else if / else, anziché di un interruttore. Questo ti permetterebbe di usare la logica che desideri.

In alternativa, se si passa la stringa nel valore enum, è possibile attivare direttamente i valori enum. Tuttavia, non è possibile attivare enum + null + altre stringhe in un unico passaggio.


L'enum è una costante, ma il risultato di .ToString () non lo è. Per quanto riguarda il compilatore, è un valore dinamico. Probabilmente hai bisogno di convertire il tuo caso switch in una serie di istruzioni if ​​/ else


Questo non è un valore statico per quanto riguarda il compilatore, poiché è una chiamata di funzione:

ORDER.partial01.ToString()

Pertanto, non è possibile utilizzarlo come confronto in un'istruzione case. Tuttavia, puoi semplicemente fare questo:

case "partial01"

Ciò funzionerebbe, poiché il valore enum e la stringa sono identici.


Come indicato da Thorarin, se la tua istruzione switch può contenere solo casi enum , converti prima la string in enum . A partire da .Net framework 4, è possibile utilizzare il Enum.TryParse()<TEnum> come definito qui e fare qualcosa del tipo:

ORDER orderEnum = ORDER.unknown;
Enum.TryParse<ORDER>(value, out orderEnum);

switch (orderEnum)
{
    case ORDER.unknown:
        // perhaps do something to deal with cases not matching
        // to known enum values, based on the string value
        break;
    case ORDER.partial01:
    case ORDER.partial12:
    case ORDER.partial23:
        // map value to known cases, etc.
        break;
}

Dal momento che C # 6, è possibile utilizzare: case nameof(SomeEnum.SomeValue):

Il nome di viene valutato al momento della compilazione, semplicemente su una stringa che corrisponde al nome (non qualificato) della variabile, del tipo o del membro specificato. Naturalmente, cambia drasticamente se dovessi cambiare il nome dell'enumerazione.


Non potresti semplicemente dire

case "partial01":

?


In alternativa all'utilizzo di if .. else , è possibile convertire prima la stringa in enum . Probabilmente non avrebbe molto senso se il numero di opzioni fosse piccolo però:

if (Enum.IsDefined(typeof(ORDER), value))
{
    switch ((ORDER)Enum.Parse(typeof(ORDER), value)
    {
        case ORDER.partial01:
            // ... 
            break;
        case ORDER.partial12:
            // etc
    }
}
else
{
    // Handle values not in enum here if needed
}

* sospiro * se solo ci fosse un T Enum.Parse<T>(string value) incorporato e una versione TryParse :)


semplicemente puoi definire una variabile globale

static ORDER orderstr;

ora puoi impostare il valore di orderstr ovunque nella pagina

public enum ORDER
{ 
    unknown,
    partial01,
    partial12,
    partial23,
}

switch (orderstr)
{
    case Order.Partial01:
        break;
    default:
        break;
}

Converti la stringa nel tuo switch in un valore enum.

(ORDER)Enum.Parse(typeof(ORDER), value, true);






enums