Koşullu Linq Sorguları

Günlük Görüntüleyici üzerinde çalışıyoruz. Kullanım, kullanıcıya, önem derecesine, vb. Göre filtreleme seçeneğine sahip olacaktır. Sql günlerinde sorgu dizesine eklerdim, ancak bunu Linq ile yapmak istiyorum. Koşullu olarak nerede cümleleri ekleyebilirim?

yalnızca belirli kriterler geçilirse filtrelemek istiyorsanız, bunun gibi bir şey yapın

var logs = from log in context.Logs
           select log;

if (filterBySeverity)
    logs = logs.Where(p => p.Severity == severity);

if (filterByUser)
    logs = logs.Where(p => p.User == user);

Bunu bu şekilde yapmak, İfade ağacınızın tam olarak istediğiniz gibi olmasını sağlayacaktır. Bu şekilde oluşturulan SQL tam olarak ihtiyacınız olan şey olacak ve daha azı olmayacak.

Bir Liste / Dizide tabanı filtrelemeniz gerekirse, aşağıdakileri kullanın:

    public List<Data> GetData(List<string> Numbers, List<string> Letters)
    {
        if (Numbers == null)
            Numbers = new List<string>();

        if (Letters == null)
            Letters = new List<string>();

        var q = from d in database.table
                where (Numbers.Count == 0 || Numbers.Contains(d.Number))
                where (Letters.Count == 0 || Letters.Contains(d.Letter))
                select new Data
                {
                    Number = d.Number,
                    Letter = d.Letter,
                };
        return q.ToList();

    }

Daren'in yanıtına benzer, ancak bir IQueryable arayüzüyle bitirdim:

IQueryable<Log> matches = m_Locator.Logs;

// Users filter
if (usersFilter)
    matches = matches.Where(l => l.UserName == comboBoxUsers.Text);

 // Severity filter
 if (severityFilter)
     matches = matches.Where(l => l.Severity == comboBoxSeverity.Text);

 Logs = (from log in matches
         orderby log.EventTime descending
         select log).ToList();

Bu, veritabanına ulaşmadan önce sorguyu oluşturur. Komut, sonunda .ToList () olana kadar çalışmayacaktır.

Koşullu bağlantı söz konusu olduğunda, filtre ve boru modeline çok düşkünüm.
http://blog.wekeroad.com/mvc-storefront/mvcstore-part-3/

Temel olarak, IQueryable ve bir parametre alan her filtre durumu için bir uzantı yöntemi oluşturursunuz.

public static IQueryable<Type> HasID(this IQueryable<Type> query, long? id)
{
    return id.HasValue ? query.Where(o => i.ID.Equals(id.Value)) : query;
}

LINQ'nun akıcı bir ifadenin ortasında koşullu olarak etkinleştirilmesine izin vermek için bunu bir uzatma yöntemiyle çözdüm. Bu, ifadeyi ifadelerle bölme ihtiyacını ortadan kaldırır if.

.If() uzatma yöntemi:

public static IQueryable<TSource> If<TSource>(
        this IQueryable<TSource> source,
        bool condition,
        Func<IQueryable<TSource>, IQueryable<TSource>> branch)
    {
        return condition ? branch(source) : source;
    }

Bu, bunu yapmanızı sağlar:

return context.Logs
     .If(filterBySeverity, q => q.Where(p => p.Severity == severity))
     .If(filterByUser, q => q.Where(p => p.User == user))
     .ToList();

Burada ayrıca IEnumerable<T>diğer LINQ ifadelerinin çoğunu işleyecek bir sürüm bulunmaktadır:

public static IEnumerable<TSource> If<TSource>(
    this IEnumerable<TSource> source,
    bool condition,
    Func<IEnumerable<TSource>, IEnumerable<TSource>> branch)
    {
        return condition ? branch(source) : source;
    }

Diğer bir seçenek de, burada tartışılan PredicateBuilder gibi bir şey kullanmak olabilir . Aşağıdaki gibi kod yazmanıza izin verir:

var newKids  = Product.ContainsInDescription ("BlackBerry", "iPhone");

var classics = Product.ContainsInDescription ("Nokia", "Ericsson")
                  .And (Product.IsSelling());

var query = from p in Data.Products.Where (newKids.Or (classics))
            select p;

Bunu yalnızca Linq 2 SQL ile çalışmak için aldığımı unutmayın. EntityFramework, bu yöntemin çalışması için gerekli olan Expression.Invoke uygulamaz. Burada bu konuyla ilgili bir sorum var .

Bunu yapmak:

bool lastNameSearch = true/false; // depending if they want to search by last name,

whereifadede buna sahip olmak :

where (lastNameSearch && name.LastNameSearch == "smith")

araçlar bu son sorgu oluşturulduğunda, eğer lastNameSearcholduğunu falsesorgu tamamen soyadı arama için herhangi bir SQL ihmal edecek.

En güzel şey değil ama bir lambda ifadesi kullanabilir ve isteğe bağlı olarak koşullarınızı geçebilirsiniz. TSQL'de parametreleri isteğe bağlı yapmak için aşağıdakilerin çoğunu yaparım:

WHERE Field = @FieldVar VEYA @FieldVar NULL IS

Aynı stili aşağıdaki lambda ile çoğaltabilirsiniz (kimlik doğrulamasını kontrol etmeye bir örnek):

MyDataContext db = new MyDataContext ();

void RunQuery (string param1, string param2, int? param3) {

Func checkUser = kullanıcı =>

((param1.Length> 0)? user.Param1 == param1: 1 == 1) &&

((param2.Length> 0)? user.Param2 == param2: 1 == 1) &&

((param3! = null)? user.Param3 == param3: 1 == 1);

Kullanıcı foundUser = db.Users.SingleOrDefault (checkUser);

}

Yakın zamanda benzer bir gereksinimim vardı ve sonunda bunu MSDN'de buldum. Visual Studio 2008 için CSharp Örnekleri

İndirmenin DynamicQuery örneğinde bulunan sınıflar, çalışma zamanında aşağıdaki biçimde dinamik sorgular oluşturmanıza olanak tanır:

var query =
db.Customers.
Where("City = @0 and Orders.Count >= @1", "London", 10).
OrderBy("CompanyName").
Select("new(CompanyName as Name, Phone)");

Bunu kullanarak çalışma zamanında dinamik olarak bir sorgu dizesi oluşturabilir ve bunu Where () yöntemine iletebilirsiniz:

string dynamicQueryString = "City = \"London\" and Order.Count >= 10"; 
var q = from c in db.Customers.Where(queryString, null)
        orderby c.CompanyName
        select c;

Bu uzantı yöntemini oluşturabilir ve kullanabilirsiniz

public static IQueryable<TSource> WhereIf<TSource>(this IQueryable<TSource> source, bool isToExecute, Expression<Func<TSource, bool>> predicate)
{
    return isToExecute ? source.Where(predicate) : source;
}

Sadece C # 's && operatörünü kullanın:

var items = dc.Users.Where(l => l.Date == DateTime.Today && l.Severity == "Critical")

Düzenleme: Ah, daha dikkatli okumalısın. Koşullu olarak nasıl ek maddeler ekleyeceğinizi öğrenmek istediniz . Bu durumda hiçbir fikrim yok. :) Muhtemelen yapacağım şey birkaç sorgu hazırlamak ve neye ihtiyaç duyduğuma bağlı olarak doğru olanı çalıştırmaktır.

Harici bir yöntem kullanabilirsiniz:

var results =
    from rec in GetSomeRecs()
    where ConditionalCheck(rec)
    select rec;

...

bool ConditionalCheck( typeofRec input ) {
    ...
}

Bu işe yarar, ancak ifade ağaçlarına bölünemez, bu da Linq'den SQL'e kontrol kodunu her kayıt için çalıştıracağı anlamına gelir.

Alternatif olarak:

var results =
    from rec in GetSomeRecs()
    where 
        (!filterBySeverity || rec.Severity == severity) &&
        (!filterByUser|| rec.User == user)
    select rec;

Bu ifade ağaçlarında işe yarayabilir, yani Linq to SQL optimize edilecektir.

Pekala, filtre koşullarını genel bir Predicates listesine koyabileceğinizi düşündüm:

    var list = new List<string> { "me", "you", "meyou", "mow" };

    var predicates = new List<Predicate<string>>();

    predicates.Add(i => i.Contains("me"));
    predicates.Add(i => i.EndsWith("w"));

    var results = new List<string>();

    foreach (var p in predicates)
        results.AddRange(from i in list where p.Invoke(i) select i);               

Bu, "ben", "meyou" ve "biçme" kelimelerini içeren bir listeyle sonuçlanır.

Tahminlerle foreach'i, tüm yüklemleri OR'lu hale getiren tamamen farklı bir işlevde yaparak bunu optimize edebilirsiniz.