Come usare LINQ Contiene() per trovare un elenco di enumerazioni?

Question

Ho un enum chiamato OrderStatus, e contiene vari stati che un ordine può essere in:

• Creato
• attesa
• attesa
• valido
• attivo
• trasformati
• Completato

Quello che voglio fare è creare una dichiarazione LINQ che mi dirà se l'OrderStaus sia valido, attivo, trasformati o Completato.

In questo momento ho qualcosa di simile:

var status in Order.Status.WHERE(status => 
     status.OrderStatus == OrderStatus.Valid || 
     status.OrderStatus == OrderStatus.Active|| 
     status.OrderStatus == OrderStatus.Processed|| 
     status.OrderStatus == OrderStatus.Completed) 

che funziona, ma è molto "prolisso". C'è un modo per convertire questo a una dichiarazione Contains() e accorciare un po '?

Answer 1

Certo:

var status in Order.Status.Where(status => new [] { 
     OrderStatus.Valid, 
     OrderStatus.Active, 
     OrderStatus.Processed, 
     OrderStatus.Completed 
    }.Contains(status.OrderStatus)); 

Si potrebbe anche definire un metodo di estensione In() che avrebbe accettato un oggetto e una matrice params, e in fondo avvolge la Contiene funzione: si

public static bool In<T>(this T theObject, params T[] collection) 
{ 
    return collection.Contains(theObject); 
} 

Questo permette di specificare la condizione in un modo più SQL-ish:

var status in Order.Status.Where(status => 
    status.OrderCode.In(
     OrderStatus.Valid, 
     OrderStatus.Active, 
     OrderStatus.Processed, 
     OrderStatus.Completed)); 

Unders tand che non tutti i provider di Linq amano i metodi di estensione personalizzati nei loro lambda. NHibernate, per esempio, non si tradurrà correttamente la funzione In() senza codice aggiuntivo per estendere il parser di espressioni, ma contiene() funziona bene. Per gli oggetti Linq 2, nessun problema.

Answer 2

Assumnig che l'enumerazione è definito nell'ordine specificato nella domanda, si potrebbe ridurre questo utilizzando un confronto integer.

var result = 
    Order.Status.Where(x => 
    (int)x >= (int)OrderStatus.Valid & 
    & (int)x <= (int)OrderStatus.Completed); 

Questo tipo di confronto però può essere considerato traballante. Un semplice riordinamento dei valori di enumerazione interromperà silenziosamente questo confronto. Preferirei mantenere la versione più verbale e probabilmente ripulirla rimodellando il confronto con un metodo separato.

Answer 3

Ho usato questa estensione:

public static bool IsIn<T>(this T value, params T[] list) 
    { 

        return list.Contains(value);   
    } 

è possibile utilizzare questo come condizione:

Where(x => x.IsIn(OrderStatus.Valid, ...) 

Answer 4

Si potrebbe mettere questi in una collezione, e l'uso:

OrderStatus searchStatus = new[] { 
       OrderStatus.Valid, 
       OrderStatus.Active, 
       OrderStatus.Processed, 
       OrderStatus.Completed }; 

var results = Order.Status.Where(status => searchStatus.Contains(status)); 

Answer 5

Se questo insieme di stati ha un significato, ad esempio quelli sono stati per gli ordini accettati, è possibile definire un metho di estensione d sul tuo enum e usalo nella tua query linq.

public static class OrderStatusExtensions 
{ 
    public static bool IsAccepted(this OrderStatuses status) 
    { 
     return status == OrderStatuses.Valid 
      || status == OrderStatuses.Active 
      || status == OrderStatuses.Processed 
      || status == OrderStatuses.Completed; 
    } 
} 

var acceptedOrders = from o in orders 
        where o.Status.IsAccepted() 
        select o; 

Anche se non si poteva dare il metodo un nome semplice, si potrebbe ancora usare qualcosa come IsValidThroughCompleted. In entrambi i casi, sembra trasmettere un significato un po 'più in questo modo.