interruttore con enum e restituire più

Ho due oggetti:interruttore con enum e restituire più

public enum BugReportStatus 
{ 
    OpenUnassigned = 0, 
    OpenAssigned = 1, 
    ClosedAsResolved = 2, 
    ClosedAsRejected = 3 
}

public enum BugReportFilter 
{ 
    Open = 1, 
    ... 
    Closed = 4, 
}

e vorrei creare una switch case in cui a seconda della BugReportFilter scegliere la mia uscita sarà una specifica BugReportStaus .

così ho creato un metodo CheckFilter

private BugReportStatus Checkfilter(BugReportFilter filter) 
{ 
    switch (filter) 
    { 
     case BugReportFilter.Open: 
      return BugReportStatus.OpenAssigned; 

     case BugReportFilter.Closed: 
      return BugReportStatus.ClosedAsResolved; 
    } 
};

Il problema è che nel caso di un'opzione di BugReportFilter.Open io tornassi BugReportStatus.OpenAssignedEBugReportStatus.OpenUnassigned, c'è un modo per concat queste due opzioni in un unico ritorno ?

fonte

2016-05-03 Pickeroll

poi tornare tipo può essere '' '' dizionario o '' '' Elenco –

Uno utilizza una matrice come oggetto ritorno o utilizzare un '' Enum' con [Flags] 'attributo. – Adwaenyth

L'unico modo in cui riesco a vedere è se gli hai resi 'Flags', ma logicamente i due sono distinti, quindi penso che non sia un buon modo per andare. usare una qualche forma di più valori nel ritorno sarebbe probabilmente il migliore, cioè un array, un elenco o ciò che hai. – DrewJordan

Si potrebbe tornare IEnumerable<BugReportStatus>:

private IEnumerable<BugReportStatus> Checkfilter(BugReportFilter filter) 
{ 
    switch (filter) 
    { 
     case BugReportFilter.Open: 
      return new[]{ BugReportStatus.OpenAssigned, BugReportStatus.OpenUnassigned }; 

     case BugReportFilter.Closed: 
      return new[]{ BugReportStatus.ClosedAsResolved }; 
    } 
};

allora si potrebbe utilizzare Enumerable.Contains per verificare se si tratta di f.e. BugReportStatus.OpenAssigned:

bool isOpenAssigned = Checkfilter(someFiler).Contains(BugReportStatus.OpenAssigned);

fonte

2016-05-03 14:46:39

Imposta la potenza delle opzioni di due, ad es.

public enum Flags 
{ 
    A = 1, 
    B = 2, 
    C = 4 
}

poi tornare Flags.B | Flags.A dalla vostra funzione (il tipo di ritorno dovrebbe essere int).

Ecco come verificare se la bandiera è impostato

bool isA = (enumFlag & Flags.A) != 0; // true means A is set

Per ulteriori informazioni, si prega di consultare here.

fonte

2016-05-03 14:46:19

Questa è di solito una buona opzione, ma non mi piace con l'esempio fornito. In che modo un bug può essere sia "assegnato" che "non assegnato" allo stesso tempo? – DrewJordan

Tecnicamente 0 non è una potenza di 2. – juharr

@Steve Tipo di reso migliore di essere –

cosa dire restituire un enumerabile?

private IEnumerable<BugReportStatus> Checkfilter(BugReportFilter filter) 
{ 
    switch (filter) 
    { 
     case BugReportFilter.Open: 
      return new List<BugReportStatus>() 
      { 
       BugReportStatus.OpenAssigned, 
       BugReportStatus.OpenUnassigned 
      }; 

     case BugReportFilter.Closed: 
      return new List<BugReportStatus>() 
      { 
       BugReportStatus.ClosedAsResolved, 
       BugReportStatus.ClosedAsRejected 
      }; 

     default: return null; 
    } 
}

fonte

2016-05-03 14:46:55

Per il vostro caso, vi consiglio di rappresentare il ritorno in diversi bit (usando il concetto di bandiere), in modo da poter concat il ritorno:

public enum BugReportStatus 
{ 
    OpenUnassigned = 1, //0000 0001 
    OpenAssigned = 2, //0000 0010 
    ClosedAsResolved = 4, //0000 0100 
    ClosedAsRejected = 8 //0000 1000 
}

Così si potrebbe fare questo:

switch (filter) 
    { 
     case BugReportFilter.Open: 
      return BugReportStatus.OpenAssigned + BugReportStatus.OpenUnassigned; //return 3 

     case BugReportFilter.Closed: 
      return BugReportStatus.ClosedAsResolved; 
    }

E modificare il tipo di ritorno a qualcosa di simile int:

private int Checkfilter(BugReportFilter filter)

E per controllare il risultato esterno, è sufficiente controllare che la bandiera esiste nel int ritorno

fonte

2016-05-03 14:47:35 Ian

Ian, c'è un motivo per farlo in questo modo invece che con Flags? – DrewJordan

@DrewJordan no, è possibile utilizzare anche l'attributo 'Flags'. Il concetto è lo stesso. È solo nel mio codice che non usi l'attributo. – Ian

OK, non mi è mai venuto in mente di implementarlo io stesso in questo modo, ero curioso di sapere se ci fossero momenti in cui questo sarebbe stato più appropriato da usare. Grazie. – DrewJordan

È possibile utilizzare l'attributo Flags per raggiungere questo obiettivo. Per utilizzare questo è necessario aumentare i valori di enum per BugReportStatus con le potenze di 2 in quanto l'enum viene trattato come un campo di bit. È inoltre necessario decorare l'enumerazione con l'attributo [Flags]. Per esempio.

[Flags] 
public enum BugReportStatus 
{ 
    OpenUnassigned = 1, 
    OpenAssigned = 2, 
    ClosedAsResolved = 4, 
    ClosedAsRejected = 8 
}

Si può quindi tornare più valori quali: return BugReportStatus.OpenAssigned | BugReportStatus.OpenUnassigned;

È possibile utilizzare il metodo Enum.HasFlags per controllare se un campo di bit specifica è stata impostata. Per esempio.

Checkfilter(BugReportFilter.Open).HasFlag(BugReportStatus.OpenAssigned) // true 
Checkfilter(BugReportFilter.Open).HasFlag(BugReportStatus.ClosedAsResolved) // false

fonte

2016-05-03 15:09:23 Fermin

interruttore con enum e restituire più

risposta

Problemi correlati