Collegamento a entità Sostituzione del metodo aggregato

Question

Sembra che Linq to Entities non supporti il ​​metodo Aggregate. Devo riscrivere questa parte di un'espressione più grande a .Select(a => a.Permissions).Aggregate((a, b) => a | b) a qualcosa che Linq alle Entità comprende. È possibile?

Forse dovrei darti una spiegazione migliore di quello che sto facendo. Devo ottenere una raccolta di Organizzatori dal database in base alle autorizzazioni dell'utente per questi Organizzatori. Le autorizzazioni vengono memorizzate come flag di bit e sono una combinazione dei seguenti elementi:

1. DefaultOrganizerPermissions - Ogni organizzatore ha alcune autorizzazioni predefinite
2. OwnerPermissions - Se l'utente è il proprietario del organizzatore, ha qualche ulteriore permesso
3. UserPermisions - Gli utenti possono essere assegnati manualmente per avere alcune autorizzazioni per Organizer
4. RolePermissions - Gli utenti possono essere membri di ruoli e questi ruoli possono essere assegnati per avere autorizzazioni aggiuntive per gli Organizzatori.

Così ho un metodo con la seguente firma

public IQueryable<Organizer> GetOrganizers(Person person, OrganizerPermissions requiredPermissions)

e al suo interno v'è un codice come questo

organizers = organizers.Where(o => ((
     // Default permissions 
     DefaultOrganizerPermissions | 
     // Owner permissions 
     (o.OwnerId == person.Id ? OwnerOrganizerPermissions : 0) | 
     // Personal permissions 
     (o.AccessIdentifier.Accesses.FirstOrDefault(a => a.Accessor is PersonalAccessor && (a.Accessor as PersonalAccessor).PersonId == person.Id) != null ? 
     (OrganizerPermissions)o.AccessIdentifier.Accesses.FirstOrDefault(a => a.Accessor is PersonalAccessor && (a.Accessor as PersonalAccessor).PersonId == person.Id).Permissions : 0) | 
     // Role permissions 
     (o.AccessIdentifier.Accesses.Any(a => a.Accessor is RoleAccessor && (a.Accessor as RoleAccessor).Role.RoleMembers.Any(rm=>rm.PersonId == person.Id)) ? 
     (OrganizerPermissions)o.AccessIdentifier.Accesses.Where(a=> a.Accessor is RoleAccessor && (a.Accessor as RoleAccessor).Role.RoleMembers.Any(rm => rm.PersonId == person.Id)).Select(a=>a.Permissions).Aggregate((a, b) => a | b) : 0) 
     ) & requiredPermissions) == requiredPermissions); 

semplificata è qualcosa di simile:

organizers = organizers.Where(o => ((
     DefaultOrganizerPermissions | 
     OwnerOrganizerPermissions | 
     UserPermisions | 
     RolePermissions 
     ) & requiredPermissions) == requiredPermissions); 

Il problema è che l'utente può essere membro di più ruoli, quindi RolePermissions è in realtà più permessi e ho bisogno di appiattirlo con OR bit a bit. Ma come, se Aggregate non è supportato?

Answer 1

Se la quantità di dati non è proibitivo grande, si potrebbe considerare chiamando .ToList() prima dell'istruzione Select(...) per leggere i dati in memoria e quindi eseguire l'aggregato LINQ to Objects

Answer 2

se le autorizzazioni è annullabile probabilmente avete bisogno inserire
a.Permissions.GetValueOrDefault()
modo che la query dovrebbe essere
.Selezionare (a => a.Permissions.GetValueOrDefault()) Aggregate ((a, b) => a | B).

Inoltre, se il provider EF non supporta Traduzione aggregata in SQL (questa parte è specifica del provider in modo che possa funzionare con un DBMS ma non con un DBMS diverso) è necessario materializzare la query con ToList() (come suggerito da @sjager).

EDIT
Il problema è che fornitore di EF non supporta traduzioni aggregata a SQL.

Io non sono un esperto di SQL Server in ogni caso si dovrebbe trovare un aggregata funzione (come SUM o AVG) che ti fa ciò che è necessario (OR bit a bit). In MySQL è BIT_OR().

Se esso non esiste, allora GAME OVER

Se esiste è possibile visualizzare il codice sorgente di fornitore di EF per SQL Server e funzione di visualizzazione wich LINQ è tradotto in quella o chiedere un'altra Question-

Answer 3

Sorprendentemente , Mi sono imbattuto nella stessa identica situazione di ieri. Quindi, come dichiarato da @bubi, senza una funzione di aggregazione corretta del server SQL è possibile non possibile.

Il modo in cui ho lavorato è creare un gruppo di gruppi di espressioni OR per ogni ruolo, ciascuno con un confronto con un ruolo dell'utente. Quindi, connettere tutti i "gruppi di espressioni OR" con il predicato AND.

E.g. se l'utente ha il valore enum di 0011, allora sarà necessario creare predicati OR per entrambi i flag 0001 e 0010. 0001 flag "OR group" assomiglia a

x=> x.Equals(0001) || x.Equals(0011) || x.Equals(0101)| || ..) 

Ma non è assolutamente consigliato.