metodo di estensione LINQ

Question

ho spesso bisogno di limitare SELECT da campi come publishStart, publishEnd, active

Ho questi campi in diversi tavoli diversi. Quindi solo le righe devono essere selezionati, che sono

a: active == true; 
b: publishStart < now; 
c: publishEnd > now; 

Così, ad esempio:

db.myTable.SingleOrDefault(a => (a.ID == _theID 
      //now the active and start-end part:    
         && ((a.publishEnd > DateTime.Now) || (a.publishEnd == null)) 
         && ((a.publishStart <= DateTime.Now) || (a.publishStart == null)) 
         && a.active == true)); 

Questo è un po 'lungo, quindi mi chiedo se è possibile creare un - metodo (estensione?) come:

db.myTable.SingleOrDefault(a => (a.ID == _theID).isActive() 

dove il isActive() fornisce le 3 linee di frammento di sopra.

Come posso fare questo? C'è un modo migliore per ripulire il codice?

Answer 1

Per definire un'estensione è necessaria una classe statica. Puoi metterlo in qualsiasi spazio dei nomi che ti piace, ricordati di includerlo nei tuoi usi.

public static class Extensions 
{ 
    public static IQueryable<T> Active<T>(this IQueryable<T> source) 
     where T : YourEntityType 
    { 
     return source.Where(a => ((a.publishEnd > DateTime.Now) || (a.publishEnd == null)) 
          && ((a.publishStart <= DateTime.Now) || (a.publishStart == null)) 
          && a.active == true); 
    } 
} 

Avviso YourEntityType lì. Viene utilizzato per garantire che il metodo sia a conoscenza dell'esistenza di publishStart, publishEnd e active. Questa dovrebbe essere la classe che implementa questi campi o un contratto (interfaccia) che li definisce.

Si potrebbe quindi chiamare questo modo:

var item = db.myTable.Active().SingleOrDefault(...); 

Altro su metodi di estensione qui: http://msdn.microsoft.com/en-us/library/bb383977.aspx

---

Come ci sono un sacco di commenti che dilagano in tutto il posto, sto andando aggiungere qui una breve spiegazione della soluzione di interfaccia ...

Non è chiaro nella domanda se esista o meno un'implementazione comune per i tre filtri f ield o un'interfaccia per definirli. In caso contrario, per il funzionamento di cui sopra, non sarà né:

1. Una classe base che implementa questi campi. In questo scenario sostituirai YourEntityType con YourBaseEntityType.
2. Un'interfaccia per definire i campi. In questo scenario è necessario che le classi implementino i campi. Se le classi sono generate automaticamente (ad es. Modello di struttura entità/db prima), allora è possibile implementare classi parziali, avendo loro implementare l'interfaccia. In questo caso sostituirai YourEntityType con IYourContract.

Answer 2

public static class Extensions 
{ 
    public static IEnumerable<MyClass> isActive(this IEnumerable<MyClass> list) 
    { 
     return list.Where(a => 
       ((a.publishEnd > DateTime.Now) || (a.publishEnd == null)) 
       && ((a.publishStart <= DateTime.Now) || (a.publishStart == null)) 
       && a.active == true); 
    } 
} 

Answer 3

basta definire un'interfaccia come questo

public interface IHaveAActivityPeriod 
{ 
    Boolean active { get; } 

    DateTime? publishStart { get; } 

    DateTime? publishEnd { get; } 
} 

e aggiungerlo a tutte le classi interessate.

public class Foo : IHaveAActivityPeriod { [...] } 

public class Bar : IHaveAActivityPeriod { [...] } 

Ora è possibile utilizzare questo metodo di estensione

public static class Extensions 
{ 
    public static Boolean IsActive(this IHaveAActivityPeriod item) 
    { 
     var now = DateTime.Now; 

     return item.active && 
       (item.publishStart <= now) 
       (!item.publishEnd.HasValue || (item.publishEnd > now)); 
    } 
} 

in ogni istanza attuazione IHaveAActivityPeriod.

var foo = new Foo(); 

var isFooActive = foo.IsActive(); 

var bar = new Bar(); 

var isBarActive = bar.IsActive(); 

ho completamente perso la possibilità di costruire un metodo di estensione che esegue il filtraggio di una sequenza invece di guardare una singola entità contemporaneamente. Prendi il metodo di estensione dalla risposta di flem e usa l'interfaccia come tipo di vincolo.

public static class Extensions 
{ 
    public IQueryable<T> IsActive<T>(this IQueryable<T> sequence) 
     where T : IHaveAActivityPeriod 
    { 
     return source.Where(item => 
        item.active && 
        (item.publishStart <= now) && 
        (!item.publishEnd.HasValue || (item.publishEnd > now)); 

    } 
}