c# - with - java enumeration syntax




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

Converti la stringa nel tuo switch in un valore enum.

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

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.


Non potresti semplicemente dire

case "partial01":

?


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.


Hai progettato questo come enum per una ragione, ma non lo stai davvero facendo come enum. Perché stai prendendo il valore enum e convertendolo in una stringa per poi utilizzarlo nell'interruttore invece di usare semplicemente enum?

Hai detto che non puoi analizzarlo in una enumerazione perché alcuni valori non rientrano nell'intervallo di enum. La domanda da porsi è, "Perché?" Qual è il punto di avere l'enum se stai permettendo valori che non sono definiti? Che cosa vuoi che succeda quando ottieni un valore che non è definito? Se è la stessa cosa per qualsiasi valore non definito, è possibile utilizzare il caso predefinito. In caso contrario, puoi includere ulteriori casi che corrispondono alla rappresentazione numerica.

Se hai davvero delle stringhe, probabilmente non vuoi usare un enum. Invece, si desidera creare una classe statica pubblica contenente costanti di stringa pubbliche, che è possibile utilizzare nel proprio switch. Il trucco qui è che la valutazione sarà effettuata in un modo sensibile al caso.

public static class Order
{
   public const string Unknown = "Unknown";
   public const string Partial01 = "Partial01";
   public const string Partial12 = "Partial12";
   public const string Partial23 = "Partial23";
}

string value = Order.Partial01
switch (value)
{
   case Order.Partial01:
      break;

    default:
       // Code you might want to run in case you are
       // given a value that doesn't match.
       break;
}

(Potresti anche voler ripulire il tuo involucro.)


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 :)


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.


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;
}






enums