Come si aggiungono clausole 'where' dinamiche a una query linq?

Question

Ho una tabella utente con una maschera di bit che contiene i ruoli dell'utente. La query LINQ seguito restituisce tutti gli utenti i cui ruoli includono 1, 4 o 16.

var users = from u in dc.Users 
      where ((u.UserRolesBitmask & 1) == 1) 
       || ((u.UserRolesBitmask & 4) == 4) 
       || ((u.UserRolesBitmask & 16) == 16) 
      select u; 

mi piacerebbe riscrivere questo nel metodo seguito per rendimenti tutti gli utenti dai ruoli dato così posso riutilizzare esso:

private List<User> GetUsersFromRoles(uint[] UserRoles) {} 

Eventuali puntatori su come creare dinamicamente la mia query? Grazie

Answer 1

È possibile utilizzare la classe PredicateBuilder.

PredicateBuilder è stato rilasciato nel LINQKit NuGet package

LINQKit è un set di estensioni per LINQ to SQL e utenti esperti Entity Framework.

Answer 2

Supponendo che i valori UserRoles siano essi stessi maschere di bit, sarebbe qualcosa di simile a questo lavoro?

private List<User> GetUsersFromRoles(uint[] UserRoles) { 
    uint roleMask = 0; 
    for (var i = 0; i < UserRoles.Length;i++) roleMask= roleMask| UserRoles[i]; 
    // roleMasknow contains the OR'ed bitfields of the roles we're looking for 

    return (from u in dc.Users where (u.UserRolesBitmask & roleMask) > 0) select u); 
} 

C'è probabilmente un bel sintassi LINQ che lavorerò al posto delle anse, ma il concetto dovrebbe essere lo stesso.

Answer 3

Come va? Non è linq dinamico, ma raggiunge l'obiettivo.

private List<User> GetUsersFromRoles(uint[] userRoles) 
{ 
    List<User> users = new List<User>(); 

    foreach(uint userRole in UserRoles) 
    { 
     List<User> usersInRole = GetUsersFromRole(userRole); 
     foreach(User user in usersInRole) 
     { 
      users.Add(user); 
     } 
    } 
    return users; 
}  

private List<User> GetUsersFromRole(uint userRole) 
{ 
    var users = from u in dc.Users 
      where ((u.UserRolesBitmask & UserRole) == UserRole) 
      select u; 

    return users;  
} 

Answer 4

Ci sono un paio di modi si può fare questo:

LINQ librerie query dinamica: http://weblogs.asp.net/scottgu/archive/2008/01/07/dynamic-linq-part-1-using-the-linq-dynamic-query-library.aspx

Espressione Alberi & Lamda espressioni: http://msdn.microsoft.com/en-us/library/bb882637.aspx

Answer 5

private List<User> GetUsersFromRoles(uint UserRoles) { 
    return from u in dc.Users    
     where (u.UserRolesBitmask & UserRoles) != 0 
     select u; 
} 

UserRoles parametri dovrebbe essere fornito, tuttavia, come una maschera di bit, invece di array.

Answer 6

Ecco un modo di aggiungere un numero variabile di dove clausole per la query LINQ. Nota che non ho ancora toccato la tua logica di maschera di bit, mi sono concentrato sul multiplo dove s.

// C# 
private List<User> GetUsersFromRoles(uint[] UserRoles) 
{ 
    var users = dc.Users; 

    foreach(uint role in UserRoles) 
    { 
     users = users.Where(u => (u.UserRolesBitmask & role) == role); 
    } 

    return users.ToList(); 
} 

---

EDIT: In realtà, questo sarà E le dove clausole e si voleva o. Il seguente approccio (un inner join) funziona in LINQ to Objects ma non può essere tradotto in SQL con LINQ to SQL:

var result = from u in Users 
      from role in UserRoles 
      where (u.UserRolesBitmask & role) == role) 
      select u;