Opérateur de requête LINQ pour la table de journal

Question

J'essaie de trouver l'opérateur de requête LINQ to SQL et la combinaison de prédicats qui peuvent fonctionner sur une table d'audit. Imaginez une table appelée Paramètre comportant trois colonnes: rowID, DefID et Value. Je veux être en mesure de vérifier que chaque DefID (dans ce cas toutes les définitions 1 à 3) a au moins une ligne qui a une valeur définie sur true.

l'expression LINQ doit retourner un booléen vrai ou faux. Par exemple,

RowID DefID Value 
1  1  true 
2  2  false 
3  3  true 

LINQ retourne false parce que defID = 2 n'a pas de valeur = true

RowID DefID Value 
1  1  true 
2  2  false 
3  2  true 

faux rapports, car defID 3 est manquant

RowID DefID Value 
1  1  true 
2  1  false 
3  2  true 
4  3  true 

renvoie true parce que toutes les définitions avoir au moins une valeur = vrai

Answer 1

Voici un exemple en utilisant des méthodes d'extension:

int[] ids = new int[] { 1, 2, 3 }; 

bool allFound = Settings.Where(s => s.Value && ids.Contains(s.DefID)) 
         .Select(s => s.DefID) 
         .Distinct() 
         .Count() == ids.Length; 

Answer 2

Je n'ai jamais utilisé linq pour sql, mais le linq t objets o ressemblerait à quelque chose comme ceci:

defIds.All(d => d.rows.Any(row => row.Value == true)) 

Pour ce faire dans SQL cru, je ne pense pas qu'il soit possible dans une requête. Vous pourriez faire quelque chose comme ça si:

select id from DefIds 
join rows on row.DefId = DefIds.ID 
where row.Value = true 

Cela vous donnera une liste des defId qui ont de vraies valeurs. Dans le code, vous pouvez alors faire quelque chose comme

DefIds.Select(d => d.id).ToArray() == (results from select).ToArray() 

Answer 3

Eh bien, il y a beaucoup de façons valables de le faire. Une façon simple est:

int[] DefIDs = new int[] {1, 2, 3}; 

bool bHasValidDefs = 
    (
    from set in myDataBase.settings 
    where 
     set.Value == true 
     && DefIDs.Contains(set.DefID) 
    select set.DefID 
    ).Distinct().Count() == DefIDs.Count(); 

Cela obtient le nombre de DefIDs uniques qui sont dans votre liste valide et ont également au moins une ligne « valeur == true ». Il s'assure ensuite que le nombre de ces DefID valides est égal à la valeur attendue que vous définissez ci-dessus.

Answer 4

Si vous êtes ok d'avoir une table ValidSettings ou SettingsMaster, vous pouvez:

bool allFound = myContext.SettingsMaster.All(m=> m.Settings.Any(s=>s.Value)); 

Pour les tables version actuelle, je serais

int[] allIds = new int[] {1, 2, 3}; 
var validIds = (
    from s in myContext.Settings 
    where s.Value 
    select s.DefId 
    ) 
    .Distinct().ToList(); 
bool allFound = allIds.All(id => validIds.Contains(id));