Switch mit ENUM und mehrere Rückgabe

Question

Ich habe zwei Objekte:

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

und

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

Und ich würde ein switch case erstellen möchten, wo auf dem BugReportFilter je meiner Ausgabe eine bestimmte BugReportStaus wählen wird .

So habe ich eine Methode CheckFilter

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

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

Das Problem ist, dass im Falle einer BugReportFilter.Open Option sollte ich zurück BugReportStatus.OpenAssignedUNDBugReportStatus.OpenUnassigned, ist es eine Möglichkeit, diese beiden Optionen in einer einzigen Rückkehr zu verketten ?

Answer 1

Sie könnten IEnumerable<BugReportStatus> zurück:

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

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

Dann könnten Sie Enumerable.Contains verwenden zu überprüfen, ob es F. E. ist BugReportStatus.OpenAssigned:

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

Answer 2

Machen Sie die Optionen Macht von zwei, z.

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

dann zurück Flags.B | Flags.A von Ihrer Funktion (der Rückgabetyp sollte int sein).

Hier ist, wie zu überprüfen, ob Flag

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

Für weitere Informationen eingestellt ist, sehen Sie bitte here.

Answer 3

was eine zählbare Rückkehr?

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

Answer 4

Für Ihren Fall empfehle ich die Rückkehr in den verschiedenen Bits darzustellen (Konzept der Flaggen verwendet wird), so dass Sie die Rückkehr verketten kann: das man tun könnte

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

So:

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

     case BugReportFilter.Closed: 
      return BugReportStatus.ClosedAsResolved; 
    } 

und ändern Sie Ihre Rückkehr Typ etwas wie int:

private int Checkfilter(BugReportFilter filter) 

Und das Ergebnis außerhalb zu überprüfen, einfach überprüfen, welche Flagge in der int Rückkehr existiert

Answer 5

Sie das Flags Attribut verwenden kann, um dies zu erreichen. Um dies zu verwenden, müssen Sie Ihre Enum-Werte für BugReportStatus um Potenzen von 2 erhöhen, da die Enumeration als ein Bitfeld behandelt wird. Sie müssen die Enumeration auch mit dem Attribut [Flags] dekorieren. Z.B.

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

Sie können dann mehrere Werte zurückgeben, wie: return BugReportStatus.OpenAssigned | BugReportStatus.OpenUnassigned;

Sie können die Enum.HasFlags-Methode verwenden, um zu überprüfen, ob ein bestimmtes Bit-Feld gesetzt wurde. Z.B.

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