Filtrage des listes à l'aide de LINQ

J'ai une liste de Personnes qui sont renvoyées à partir d'une application externe et je suis de la création d'une liste d'exclusion dans mon local de l'application de me donner la possibilité de supprimer manuellement les personnes de la liste.

J'ai une clé composite que j'ai créé, qui est commun aux deux et je veux trouver un moyen efficace de les enlever de ma Liste à l'aide de ma Liste

e.g

class Person
{
    prop string compositeKey { get; set; }
}

class Exclusions
{
    prop string compositeKey { get; set; }
}

List<Person> people = GetFromDB;

List<Exclusions> exclusions = GetFromOtherDB;

List<Person> filteredResults = People - exclustions using the composite key as a comparer

Je pensais que LINQ a été le moyen idéal de le faire, mais après avoir essayé les jointures, les méthodes d'extension, à l'aide des rendements, etc. Je suis toujours avoir des ennuis.

Si c'était SQL je voudrais utiliser un not in (?,?,?) requête.

source d'informationauteur

c#linq linq-to-objects list

28

Ont un look à la Sauf méthode, que vous pouvez utiliser comme ceci:
```
var resultingList = 
    listOfOriginalItems.Except(listOfItemsToLeaveOut, equalityComparer)
```
Vous aurez envie d'utiliser la surcharge de travail, je suis lié à, qui permet de spécifier une coutume IEqualityComparer. De cette façon, vous pouvez spécifier la façon dont les éléments match en fonction de votre clé composite. (Si vous avez déjà remplacé égal à Égal, cependant, vous ne devriez pas besoin de la IEqualityComparer.)

Edit: Puisqu'il semble que vous êtes à l'aide de deux différents types de classes, voici un autre moyen qui pourrait être plus simple. En supposant un List<Person> appelé persons et un List<Exclusion> appelé exclusions:
```
var exclusionKeys = 
        exclusions.Select(x => x.compositeKey);
var resultingPersons = 
        persons.Where(x => !exclusionKeys.Contains(x.compositeKey));
```
En d'autres termes: pour choisir les exclusions juste les touches, puis choisissez l'une de personnes tous les objets de la Personne qui ne pas aucun de ces touches.
4

Je voudrais juste utiliser la méthode FindAll sur la Liste de classe. c'est à dire:
```
List<Person> filteredResults = 
    people.FindAll(p => return !exclusions.Contains(p));
```
Ne sais pas si la syntaxe correspondent exactement à celles de vos objets, mais je pense que vous voyez où je veux en venir.

Un grand merci pour ce gars.

Je mangaged pour obtenir ce pour une ligne:

  var results = from p in People 
                where !(from e in exclusions 
                        select e.CompositeKey).Contains(p.CompositeKey) 
                select p;

Merci encore à tout le monde.

Je ne pouvais pas comprendre comment le faire dans le plus pur MS LINQ, j'ai donc écrit ma propre méthode d'extension pour le faire:

public static bool In<T>(this T objToCheck, params T[] values)
{
    if (values == null || values.Length == 0) 
    {
        return false; //early out
    }
    else
    {
        foreach (T t in values)
        {
            if (t.Equals(objToCheck))
                return true;   //RETURN found!
        }

        return false; //nothing found
    }
}

1

Vous pouvez utiliser le "Sauf" méthode d'extension (voir http://msdn.microsoft.com/en-us/library/bb337804.aspx)

Dans votre code
```
var difference = people.Except(exclusions);
```

Je voudrais faire quelque chose comme ça, mais je parie qu'il y est un moyen plus simple. je pense que le sql de linqtosql serait d'utiliser un select de personne Où n'EXISTE PAS(sélectionnez à partir de votre liste d'exclusion)

static class Program
{
    public class Person
    {
        public string Key { get; set; }
        public Person(string key)
        {
           Key = key;
        }
    }
    public class NotPerson
    {
        public string Key { get; set; }
        public NotPerson(string key)
        {
           Key = key;
        }
    }
    static void Main()
    {

       List<Person> persons = new List<Person>()
       { 
           new Person ("1"),
           new Person ("2"),
           new Person ("3"),
           new Person ("4")
       };

       List<NotPerson> notpersons = new List<NotPerson>()
       { 
           new NotPerson ("3"),
           new NotPerson ("4")
       };

       var filteredResults = from n in persons
                             where !notpersons.Any(y => n.Key == y.Key)
                             select n;

       foreach (var item in filteredResults)
       {
          Console.WriteLine(item.Key);
       }
    }
 }

Ce LINQ ci-dessous va générer le SQL pour une jointure externe gauche, puis prenez tous les résultats qui ne sont pas de trouver une correspondance dans votre liste d'exclusion.

List<Person> filteredResults =from p in people
        join e in exclusions on p.compositeKey equals e.compositeKey into temp
        from t in temp.DefaultIfEmpty()
        where t.compositeKey == null
        select p

laissez-moi savoir si cela fonctionne!

var thisList = new List<string>{ "a", "b", "c" };
var otherList = new List<string> {"a", "b"};

var theOnesThatDontMatch = thisList
        .Where(item=> otherList.All(otherItem=> item != otherItem))
        .ToList();

var theOnesThatDoMatch = thisList
        .Where(item=> otherList.Any(otherItem=> item == otherItem))
        .ToList();

Console.WriteLine("don't match: {0}", string.Join(",", theOnesThatDontMatch));
Console.WriteLine("do match: {0}", string.Join(",", theOnesThatDoMatch));

//Output:
//don't match: c
//do match: a,b

Adapter la liste des types et des lambdas en conséquence, et vous pouvez filtrer quoi que ce soit.

https://dotnetfiddle.net/6bMCvN

-1

            var result = Data.Where(x =>
            {
            bool condition = true;
            double accord = (double)x[Table.Columns.IndexOf(FiltercomboBox.Text)];
            return condition && accord >= double.Parse(FilterLowertextBox.Text) && accord <= double.Parse(FilterUppertextBox.Text); 
        });

Vous devez vous connecter pour publier un commentaire.