Wie kann ich die Entity-Framework-Abfragen dynamisch?

Ich bin ganz neu bei Entity Framework und ich habe eine Frage zum filtern von Daten.

Habe ich zwei verschiedene Log-Einheiten, Sie sind: DiskLog und NetworkLog. Diese Entitäten sind abgeleitet aus Log Einheit. Hier ist ein code aus meiner C# app:

public class Log { ... }
public class DiskLog : Log { ... }
public class NetworkLog : Log { ... }

public enum LogType
{
    NotInitialized = 0,
    Disk,
    Network
}

public List<Log> GetWithFilter(
    Guid userKey, 
    int nSkip, 
    int nTake, 
    DateTime dateFrom = DateTime.MinValue, 
    DateTime dateTo = DateTime.MaxValue, 
    LogType logType = LogType.NotInitialized, 
    int computerId = 0)
{
    //need to know how to optimize ...

    return ...
}

Natürlich, ich habe bereits eine funktionierende app und Datenbank-Tabellen erstellt. Was ich will zu tun ist, um die Funktion GetWithFilter Arbeit. Ich habe mehrere der Ausführung Möglichkeiten, die es gibt:

if logType == LogType.Disk && computerId <= 0 (es bedeutet, dass es keine Notwendigkeit zu verwenden computerId parameter in der Abfrage, wählen Sie DiskLog Entitäten nur)
if logType == LogType.Disk && computerId > 0 (bedeutet, ich habe mit computerId parameter, wählen Sie DiskLog Entitäten nur)
if logType == LogType.NotInitialized && computerId <= 0 (keine Notwendigkeit zu verwenden computerId und logType, wählen Sie einfach die Entitäten, DiskLog und NetworkLog)
if logType == LogType.NotInitialized && computerId > 0 (wählen Sie alle Arten von Protokolle für bestimmte computer)
if logType == LogType.Network && computerId <= 0 (wählen Sie alle NetworkLog Personen)
if logType == LogType.Network && computerId > 0 (wählen Sie alle NetworkLog Entitäten für den angegebenen computer)

Wie Sie sehen können, es gibt viele Optionen verfügbar. Und ich habe zu schreiben 6 Anfragen wie diese:

context.LogSet
    .OfType<DiskLog>
    .Where(x => x.Computer.User.UserKey == userKey)
    .Where(x => x.DateStamp >= dateFrom && x.DateStamp < dateTo)
    .OrderByDescending(x => x.Id)
    .Skip(nSkip)
    .Take(nTake)
    .ToList();

context.LogSet
    .OfType<DiskLog>
    .Where(x => x.Computer.User.UserKey == userKey)
    .Where(x => x.DateStamp >= dateFrom && x.DateStamp < dateTo)
    .Where(x => x.Computer.Id == computerId)
    .OrderByDescending(x => x.Id)
    .Skip(nSkip)
    .Take(nTake)
    .ToList();

context.LogSet
    .Where(x => x.Computer.User.UserKey == userKey)
    .Where(x => x.DateStamp >= dateFrom && x.DateStamp < dateTo)
    .OrderByDescending(x => x.Id)
    .Skip(nSkip)
    .Take(nTake)
    .ToList(); //simplest one!

context.LogSet
    .Where(x => x.Computer.User.UserKey == userKey)
    .Where(x => x.DateStamp >= dateFrom && x.DateStamp < dateTo)
    .Where( x => x.Computer.Id == computerId)
    .OrderByDescending(x => x.Id)
    .Skip(nSkip)
    .Take(nTake)
    .ToList();

context.LogSet
    .OfType<NetworkLog>
    .Where(x => x.Computer.User.UserKey == userKey)
    .Where(x => x.DateStamp >= dateFrom && x.DateStamp < dateTo)
    .OrderByDescending(x => x.Id)
    .Skip(nSkip)
    .Take(nTake)
    .ToList();

context.LogSet
    .OfType<NetworkLog>
    .Where(x => x.Computer.User.UserKey == userKey)
    .Where(x => x.DateStamp >= dateFrom && x.DateStamp < dateTo)
    .Where( x => x.Computer.Id == computerId)
    .OrderByDescending(x => x.Id)
    .Skip(nSkip)
    .Take(nTake)
    .ToList();

Also die Frage ist, wie kann ich den code optimieren? Wo ist der Weg, es besser zu machen.

InformationsquelleAutor Roman Pushkin | 2011-05-04

c#entity-framework filter filtering linq

Können Sie ganz einfach mit dem Abfrage-compossition.

Du das erste mal mit der Abfrage.

IQueryable<Log> query = context.LogSet;

Sie, die Sie verfassen, sub-queries.

if (logType == LogType.Disk)
{
    query = query.OfType<DiskLog>(); //not sure if you need conversion here
} 
else if (logType == LogType.Network)
{
    query = query.OfType<NetworkLog>(); //not sure if you need conversion here
}

query = query.Where(x => x.Computer.User.UserKey == userKey);

if (computerId != 0)
   query = query.Where( x => x.Computer.Id == computerId);

//.. and so on

query = query.OrderByDescending(x => x.Id).Skip(nSkip).Take(nTake);

return query.ToList(); //do database call, materialize the data and return;

Und ich würde empfehlen, mit nullable-Wertetypen für die Fälle, wenn es keinen Wert.

InformationsquelleAutor Euphoric

Können Sie Func<T,bool> um dies zu optimieren,

IEnumerable<T> Select<T>(IEnumerable<T> source, Func<T, bool> userKeyFunc, Func<T, bool> dateFunc, int skip, int take)
{
    return source.OfType<T>().Where(userKeyFunc).Where(dateFunc).Skip(skip).Take(take);
}

Dann verwenden:

var result = Select<NetworkLog>(context.LogSet,x => x.Computer.User.UserKey == userKey,
                                x => x.DateStamp >= dateFrom && x.DateStamp < dateTo, nSkip,nTake)