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