c# - net - Switch con enum y retorno múltiple

switch case enum

Question

Tengo dos objetos:

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

y

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

Y me gustaría crear una switch case en la que, dependiendo de BugReportFilter mi salida sea un BugReportStaus específico.

Así que creé un método CheckFilter

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

El problema es que en el caso de una opción BugReportFilter.Open debería devolver BugReportStatus.OpenAssigned AND BugReportStatus.OpenUnassigned , ¿hay alguna forma de concaturar estas dos opciones en una sola devolución?

Answer 1

¿Qué hay de devolver un enumerable?

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 2

Haga que las opciones tengan la potencia de dos, por ejemplo

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

luego devuelve Flags.B | Flags.A Flags.B | Flags.A desde su función (el tipo de retorno debe ser int ).

Aquí es cómo verificar si se establece el indicador

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

Para más información, mira aquí .

Answer 3

Para su caso, recomiendo representar la devolución en diferentes bits (utilizando el concepto de banderas) para que pueda concat la devolución:

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

Por lo tanto, podrías hacer esto:

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

Y cambie su tipo de devolución a algo así como int :

private int Checkfilter(BugReportFilter filter)

Y para verificar el resultado afuera, simplemente verifique qué bandera existe en el retorno int

Answer 4

Podría devolver 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 };
}
};

Entonces podrías usar Enumerable.Contains para verificar si es fe BugReportStatus.OpenAssigned :

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

Answer 5

Puede usar el atributo Flags para lograr esto. Para usar esto, necesitas aumentar tus valores enum para BugReportStatus por potencias de 2 ya que la enumeración se trata como un campo de bit. También necesita decorar la enumeración con el atributo [Flags] . P.ej

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

A continuación, puede devolver varios valores tales como: return BugReportStatus.OpenAssigned | BugReportStatus.OpenUnassigned; return BugReportStatus.OpenAssigned | BugReportStatus.OpenUnassigned;

Puede usar el método Enum.HasFlags para verificar si se ha establecido un campo de bit específico. P.ej

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