È possibile fare un metodo generico con queste due istruzioni linq?

Question

Ho 2 istruzioni linq - attualmente nel mezzo di un blocco di commutazione. Le dichiarazioni sono sotto.

pwStartTime = lender.ApplicationWindows 
.Where(w => w.Name == pwPeriod && w.EndTime.TimeOfDay > dateToCheck.TimeOfDay) 
.Select(w => w.StartTime) 
.FirstOrDefault(); 


pwStartTime = lender.TransferWindows 
.Where(w => w.Name == pwPeriod && w.EndTime.TimeOfDay > dateToCheck.TimeOfDay) 
.Select(w => w.StartTime) 
.FirstOrDefault(); 

Come si può vedere l'unica differenza è che si riferiscono a due diverse proprietà di "creditore", tuttavia, tutti gli elementi utilizzati nella query LINQ sono identici a "ApplicationWindows" e "TransferWindows", pur non sono gli stessi oggetti e ognuno contiene altre proprietà uniche.

Quindi, è possibile restituire w.StartDate tramite un metodo generico?

Grazie in anticipo.

// Ecco le 2 classi

public class ApplicationWindow 
{ 
    public string Name { get; set; } 
    public DateTime StartTime { get; set; } 
    public DateTime EndTime { get; set; } 
} 

public class TransferWindow 
{ 
    public string Name { get; set; } 

    public DateTime StartTime { get; set; } 

    public DateTime EndTime { get; set; } 

    [XmlIgnore] 
    public TimeSpan Cycle { get; set; } 

    [Browsable(false)] 
    [XmlElement("Cycle")] 
    public string CycleString 
    { 
     get { return XmlConvert.ToString(Cycle); } 
     set { Cycle = value.IsNullOrEmpty() ? TimeSpan.Zero : XmlConvert.ToTimeSpan(value); } 
    } 
} 

Answer 1

Perché non creare un interfaccia o classe base astratta per TransferWindow e ApplicationWindow, che definisce le proprietà comuni? Poi si può fare qualcosa di simile (supponendo che lender.TransferWindows e lender.ApplicationWindows sono liste di loro rispettive classi - se non, modificare firma del metodo a seconda dei casi):

public DateTime GetStartTime(IList<Window> windows, DateTime dateToCheck, string pwPeriod) 
{ 
    return windows 
    .Where(w => w.Name == pwPeriod && w.EndTime.TimeOfDay > dateToCheck.TimeOfDay) 
    .Select(w => w.StartTime) 
    .FirstOrDefault(); 
} 

Answer 2

Se ApplicationWindows e TransferWindows implementano un'interfaccia comune, allora si può fare il a seguire;

public DateTime GetStartTime(IEnumerable<IWindow> windows, string pwPeriod, TimeSpan timeOfDay) 
{ 
    return windows.Where(w => w.Name == pwPeriod && w.EndTime.TimeOfDay > timeOfDay) 
     .Select(w => w.StartTime) 
     .FirstOrDefault(); 
} 

UPDATE

Se si utilizza LINQ to SQL, allora si può avere questi implementano un'interfaccia con la creazione di una classe parziale con lo stesso nome (e nello stesso spazio dei nomi), come le due classi finestra , dicendo che questo implementa l'interfaccia.

Credo che questo dovrebbe funzionare, anche se non l'ho fatto da un po 'e l'ho fatto con VB.NET.

Answer 3

Un esempio di cosa si può fare con le interfacce:

pwStartTime = lender.ApplicationWindows.FirstOrDefaultDateTime(pwPeriod, dateToCheck); 
pwStartTime = lender.TransferWindows.FirstOrDefaultDateTime(pwPeriod, dateToCheck); 

public interface IWindow 
{ 
    string Name { get; } 
    public DateTime StartTime { get; } 
    public DateTime EndTime { get; } 
} 

public class ApplicationWindow : IWindow 
{ 
    public string Name { get; set; } 
    public DateTime StartTime { get; set; } 
    public DateTime EndTime { get; set; } 
} 

public class TransferWindow : IWindow 
{ 
    public string Name { get; set; } 
    public DateTime StartTime { get; set; } 
    public DateTime EndTime { get; set; } 
} 

public static class IWindowExt 
{ 
    public static DateTime FirstOrDefaultDateTime(this IEnumerable<IWindow> windows, string pwPeriod, DateTime dateToCheck) 
    { 
     return windows 
       .Where(w => w.Name == pwPeriod && w.EndTime.TimeOfDay > dateToCheck.TimeOfDay) 
       .Select(w => w.StartTime) 
       .FirstOrDefault(); 
    } 
} 

Quando si dispone di metodo che mirano a una sola interfaccia, la soluzione più bella è quella di creare metodo di estensione associata.