Фильтрация списков с использованием LINQ
У меня есть список людей, которые возвращаются из внешнего приложения, и я создаю список исключений в моем локальном приложении, чтобы дать мне возможность вручную удалять людей из списка.
У меня есть составной ключ, который я создал, который является общим для обоих, и я хочу найти эффективный способ удаления людей из моего списка с помощью моего списка
например
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
Я думал, что LINQ был идеальным способом сделать это, но после попытки объединений, методов расширения, использования выходов и т. д. У меня все еще возникают проблемы.
Если бы это был SQL, я бы использовал запрос not in (?,?,?).
Ответы 9
Я не мог понять, как это сделать в чистом MS LINQ, поэтому написал для этого свой собственный метод расширения:
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
}
}
Я думаю, что мой код выглядит чище, и с помощью arrary параметров я могу создать свой список из параметров, встроенных в тот же запрос LINQ, вместо того, чтобы создавать новый список в коде повсюду. У меня это хорошо сработало.
Я бы просто использовал метод FindAll в классе List. то есть:
List<Person> filteredResults =
people.FindAll(p => return !exclusions.Contains(p));
Не уверен, что синтаксис точно соответствует вашим объектам, но я думаю, вы видите, к чему я клоню.
FindAll был для меня правильным подходом. У меня был общий список, который мне нужно было передать через предикат bool, чтобы определить, должен ли возвращаемый список содержать этот элемент. Что-то вроде следующего - это то, что я искал. var permitted = overall.FindAll(x => IsPermitted(x));
Вы можете использовать метод расширения "Except" (см. http://msdn.microsoft.com/en-us/library/bb337804.aspx)
В вашем коде
var difference = people.Except(exclusions);
О, и вы можете предоставить свой собственный компаратор. Помните, что Except оптимизирован, потому что внутри он использует структуру Set.
Взгляните на метод Кроме, который вы используете следующим образом:
var resultingList =
listOfOriginalItems.Except(listOfItemsToLeaveOut, equalityComparer)
Вы захотите использовать перегрузку, с которой я связался, которая позволяет указать настраиваемый IEqualityComparer. Таким образом вы можете указать, как элементы совпадают на основе вашего составного ключа. (Однако, если вы уже переопределили Equals, IEqualityComparer вам не понадобится.)
Редактировать: Поскольку кажется, что вы используете два разных типа классов, вот еще один способ, который может быть проще. Предположим, что List<Person> называется persons, а List<Exclusion> называется exclusions:
var exclusionKeys =
exclusions.Select(x => x.compositeKey);
var resultingPersons =
persons.Where(x => !exclusionKeys.Contains(x.compositeKey));
Другими словами: выберите из исключений только ключи, затем выберите из лиц все объекты Person, у которых не есть какие-либо из этих ключей.
в его примере это две разные таблицы. Итак, личность и исключения - это разные типы, можно ли тогда использовать «Исключение»? потому что вы хотите передать IEnumerable <Exclusions> в person.Except <Person> (IEnumerable <Person>, IEqualityComparer <Person>);
Хорошее замечание, Хат. Я добавил еще один метод, который не требует одного и того же типа для каждого списка.
Я бы сделал что-то подобное, но держу пари, что есть способ попроще. Я думаю, что sql из linqtosql будет использовать выбор от человека, где НЕ СУЩЕСТВУЕТ (выберите из списка исключений)
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);
}
}
}
Этот LINQ ниже сгенерирует SQL для левого внешнего соединения, а затем возьмет все результаты, которые не находят совпадения в вашем списке исключений.
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
дайте мне знать, если это сработает!
Большое спасибо за это, ребята.
Мне удалось свести это к одной строке:
var results = from p in People
where !(from e in exclusions
select e.CompositeKey).Contains(p.CompositeKey)
select p;
Еще раз спасибо всем.
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);
});
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
Соответственно измените типы списков и лямбды, и вы сможете отфильтровать все, что угодно.
вы написали способ сделать "item.In (list)". уже есть метод, который выполняет «list.Contains (item)». так что вы можете реализовать In () как {return values.Contains (objToCheck); }