LINQs Distinct () für eine bestimmte Eigenschaft

Ich spiele mit LINQ, um mehr darüber zu erfahren, aber ich kann nicht herausfinden, wie Distinctich es verwenden soll, wenn ich keine einfache Liste habe (eine einfache Liste von ganzen Zahlen ist ziemlich einfach, das ist nicht die Frage). Was kann ich tun, wenn Distinct für eine Liste eines Objekts für eine oder mehrere Eigenschaften des Objekts verwendet werden soll?

Beispiel: Wenn ein Objekt ist Person, mit Eigenschaft Id. Wie kann ich alle Personen abrufen und Distinctmit der Eigenschaft Iddes Objekts verwenden?

Person1: Id=1, Name="Test1"
Person2: Id=1, Name="Test1"
Person3: Id=2, Name="Test2"

Wie kann ich nur Person1und bekommen Person3? Ist das möglich?

Wenn dies mit LINQ nicht möglich ist, wie lässt sich eine Liste in PersonAbhängigkeit von einigen Eigenschaften in .NET 3.5 am besten erstellen ?

EDIT : Dies ist jetzt Teil von MoreLINQ .

Was Sie brauchen, ist ein "Unterscheidungsmerkmal" effektiv. Ich glaube nicht, dass es Teil von LINQ ist, obwohl es ziemlich einfach zu schreiben ist:

public static IEnumerable<TSource> DistinctBy<TSource, TKey>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
    HashSet<TKey> seenKeys = new HashSet<TKey>();
    foreach (TSource element in source)
    {
        if (seenKeys.Add(keySelector(element)))
        {
            yield return element;
        }
    }
}

Um die unterschiedlichen Werte nur anhand der IdEigenschaft zu ermitteln, können Sie Folgendes verwenden:

var query = people.DistinctBy(p => p.Id);

Um mehrere Eigenschaften zu verwenden, können Sie anonyme Typen verwenden, die die Gleichheit entsprechend implementieren:

var query = people.DistinctBy(p => new { p.Id, p.Name });

Ungetestet, aber es sollte funktionieren (und es wird jetzt zumindest kompiliert).

Es wird jedoch der Standardkomparator für die Schlüssel angenommen. Wenn Sie einen Gleichheitsvergleich übergeben möchten, geben Sie ihn einfach an den HashSetKonstruktor weiter.

Was ist, wenn ich eine eindeutige Liste basierend auf einer oder mehreren Eigenschaften erhalten möchte ?

Einfach! Sie möchten sie gruppieren und einen Gewinner aus der Gruppe auswählen.

List<Person> distinctPeople = allPeople
  .GroupBy(p => p.PersonId)
  .Select(g => g.First())
  .ToList();

Wenn Sie Gruppen für mehrere Eigenschaften definieren möchten, gehen Sie wie folgt vor:

List<Person> distinctPeople = allPeople
  .GroupBy(p => new {p.PersonId, p.FavoriteColor} )
  .Select(g => g.First())
  .ToList();

Verwenden:

List<Person> pList = new List<Person>();
/* Fill list */

var result = pList.Where(p => p.Name != null).GroupBy(p => p.Id).Select(grp => grp.FirstOrDefault());

Das wherehilft Ihnen , die Einträge zu filtern (könnte komplexer sein) und die groupbyund selectführen die unterschiedliche Funktion.

Sie können auch die Abfragesyntax verwenden, wenn Sie möchten, dass sie alle LINQ-ähnlich aussieht:

var uniquePeople = from p in people
                   group p by new {p.ID} //or group by new {p.ID, p.Name, p.Whatever}
                   into mygroup
                   select mygroup.FirstOrDefault();

Ich denke es ist genug:

list.Select(s => s.MyField).Distinct();

Lösung Gruppieren Sie zuerst nach Ihren Feldern und wählen Sie dann das erste oder Standardelement aus.

    List<Person> distinctPeople = allPeople
   .GroupBy(p => p.PersonId)
   .Select(g => g.FirstOrDefault())
   .ToList();

Sie können dies mit dem Standard tun Linq.ToLookup(). Dadurch wird eine Sammlung von Werten für jeden eindeutigen Schlüssel erstellt. Wählen Sie einfach den ersten Artikel in der Sammlung aus

Persons.ToLookup(p => p.Id).Select(coll => coll.First());

Der folgende Code entspricht funktional der Antwort von Jon Skeet .

Unter .NET 4.5 getestet, sollte auf jeder früheren Version von LINQ funktionieren.

public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
  this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
  HashSet<TKey> seenKeys = new HashSet<TKey>();
  return source.Where(element => seenKeys.Add(keySelector(element)));
}

Schauen Sie sich übrigens Jon Skeets neueste Version von DistinctBy.cs in Google Code an .

Ich habe einen Artikel geschrieben, in dem erklärt wird, wie die Distinct-Funktion erweitert wird, sodass Sie wie folgt vorgehen können:

var people = new List<Person>();

people.Add(new Person(1, "a", "b"));
people.Add(new Person(2, "c", "d"));
people.Add(new Person(1, "a", "b"));

foreach (var person in people.Distinct(p => p.ID))
    // Do stuff with unique list here.

Hier ist der Artikel: Erweitern von LINQ - Angeben einer Eigenschaft in der Distinct-Funktion

Persönlich benutze ich die folgende Klasse:

public class LambdaEqualityComparer<TSource, TDest> : 
    IEqualityComparer<TSource>
{
    private Func<TSource, TDest> _selector;

    public LambdaEqualityComparer(Func<TSource, TDest> selector)
    {
        _selector = selector;
    }

    public bool Equals(TSource obj, TSource other)
    {
        return _selector(obj).Equals(_selector(other));
    }

    public int GetHashCode(TSource obj)
    {
        return _selector(obj).GetHashCode();
    }
}

Dann eine Erweiterungsmethode:

public static IEnumerable<TSource> Distinct<TSource, TCompare>(
    this IEnumerable<TSource> source, Func<TSource, TCompare> selector)
{
    return source.Distinct(new LambdaEqualityComparer<TSource, TCompare>(selector));
}

Schließlich die beabsichtigte Verwendung:

var dates = new List<DateTime>() { /* ... */ }
var distinctYears = dates.Distinct(date => date.Year);

Der Vorteil, den ich bei diesem Ansatz gefunden habe, ist die Wiederverwendung von LambdaEqualityComparer Klasse für andere Methoden, die eine akzeptieren IEqualityComparer. (Oh, und ich überlasse das yieldZeug der ursprünglichen LINQ-Implementierung ...)

Falls Sie eine Distinct-Methode für mehrere Eigenschaften benötigen, können Sie meine PowerfulExtensions überprüfen Bibliothek . Derzeit befindet es sich in einem sehr jungen Stadium, aber Sie können bereits Methoden wie Distinct, Union, Intersect, außer für eine beliebige Anzahl von Eigenschaften verwenden.

So verwenden Sie es:

using PowerfulExtensions.Linq;
...
var distinct = myArray.Distinct(x => x.A, x => x.B);

Als wir in unserem Projekt vor einer solchen Aufgabe standen, haben wir eine kleine API definiert, um Komparatoren zu erstellen.

Der Anwendungsfall war also wie folgt:

var wordComparer = KeyEqualityComparer.Null<Word>().
    ThenBy(item => item.Text).
    ThenBy(item => item.LangID);
...
source.Select(...).Distinct(wordComparer);

Und die API selbst sieht folgendermaßen aus:

using System;
using System.Collections;
using System.Collections.Generic;

public static class KeyEqualityComparer
{
    public static IEqualityComparer<T> Null<T>()
    {
        return null;
    }

    public static IEqualityComparer<T> EqualityComparerBy<T, K>(
        this IEnumerable<T> source,
        Func<T, K> keyFunc)
    {
        return new KeyEqualityComparer<T, K>(keyFunc);
    }

    public static KeyEqualityComparer<T, K> ThenBy<T, K>(
        this IEqualityComparer<T> equalityComparer,
        Func<T, K> keyFunc)
    {
        return new KeyEqualityComparer<T, K>(keyFunc, equalityComparer);
    }
}

public struct KeyEqualityComparer<T, K>: IEqualityComparer<T>
{
    public KeyEqualityComparer(
        Func<T, K> keyFunc,
        IEqualityComparer<T> equalityComparer = null)
    {
        KeyFunc = keyFunc;
        EqualityComparer = equalityComparer;
    }

    public bool Equals(T x, T y)
    {
        return ((EqualityComparer == null) || EqualityComparer.Equals(x, y)) &&
                EqualityComparer<K>.Default.Equals(KeyFunc(x), KeyFunc(y));
    }

    public int GetHashCode(T obj)
    {
        var hash = EqualityComparer<K>.Default.GetHashCode(KeyFunc(obj));

        if (EqualityComparer != null)
        {
            var hash2 = EqualityComparer.GetHashCode(obj);

            hash ^= (hash2 << 5) + hash2;
        }

        return hash;
    }

    public readonly Func<T, K> KeyFunc;
    public readonly IEqualityComparer<T> EqualityComparer;
}

Weitere Details finden Sie auf unserer Website: IEqualityComparer in LINQ .

Mit DistinctBy () können Sie Distinct-Datensätze anhand einer Objekteigenschaft abrufen. Fügen Sie einfach die folgende Anweisung hinzu, bevor Sie sie verwenden:

Verwenden von Microsoft.Ajax.Utilities;

und verwenden Sie es dann wie folgt:

var listToReturn = responseList.DistinctBy(x => x.Index).ToList();

Dabei ist 'Index' die Eigenschaft, für die die Daten unterschiedlich sein sollen.

Sie können es so machen (wenn auch nicht blitzschnell):

people.Where(p => !people.Any(q => (p != q && p.Id == q.Id)));

Das heißt: "Wählen Sie alle Personen aus, bei denen die Liste keine andere Person mit derselben ID enthält."

Wohlgemerkt, in Ihrem Beispiel würde das nur Person 3 auswählen. Ich bin mir nicht sicher, wie ich aus den beiden vorherigen sagen soll, was Sie wollen.

Wenn Sie die MoreLinq-Bibliothek nicht zu Ihrem Projekt hinzufügen möchten, um die DistinctByFunktionalität zu erhalten , können Sie das gleiche Endergebnis erzielen, indem Sie die Überladung der Linq- DistinctMethode verwenden, die ein IEqualityComparerArgument enthält.

Sie erstellen zunächst eine generische benutzerdefinierte Gleichheitsvergleichsklasse, die die Lambda-Syntax verwendet, um einen benutzerdefinierten Vergleich zweier Instanzen einer generischen Klasse durchzuführen:

public class CustomEqualityComparer<T> : IEqualityComparer<T>
{
    Func<T, T, bool> _comparison;
    Func<T, int> _hashCodeFactory;

    public CustomEqualityComparer(Func<T, T, bool> comparison, Func<T, int> hashCodeFactory)
    {
        _comparison = comparison;
        _hashCodeFactory = hashCodeFactory;
    }

    public bool Equals(T x, T y)
    {
        return _comparison(x, y);
    }

    public int GetHashCode(T obj)
    {
        return _hashCodeFactory(obj);
    }
}

Dann verwenden Sie es in Ihrem Hauptcode wie folgt:

Func<Person, Person, bool> areEqual = (p1, p2) => int.Equals(p1.Id, p2.Id);

Func<Person, int> getHashCode = (p) => p.Id.GetHashCode();

var query = people.Distinct(new CustomEqualityComparer<Person>(areEqual, getHashCode));

Voila! :) :)

Das Obige setzt Folgendes voraus:

• Eigentum Person.Idist vom Typint
• Die peopleSammlung enthält keine Nullelemente

Wenn die Sammlung Nullen enthalten könnte, schreiben Sie die Lambdas einfach neu, um nach Null zu suchen, z.

Func<Person, Person, bool> areEqual = (p1, p2) => 
{
    return (p1 != null && p2 != null) ? int.Equals(p1.Id, p2.Id) : false;
};

BEARBEITEN

Dieser Ansatz ähnelt dem in der Antwort von Vladimir Nesterovsky, ist jedoch einfacher.

Es ähnelt auch dem in Joels Antwort, ermöglicht jedoch eine komplexe Vergleichslogik mit mehreren Eigenschaften.

Wenn sich Ihre Objekte jedoch nur bis dahin unterscheiden können, Idhat ein anderer Benutzer die richtige Antwort gegeben. Sie müssen lediglich die Standardimplementierungen von GetHashCode()und Equals()in Ihrer PersonKlasse überschreiben und dann einfach die Out-of-the-Box- Distinct()Methode von Linq zum Filtern verwenden Duplikate aus.

Der beste Weg, dies zu tun, der mit anderen .NET-Versionen kompatibel ist, besteht darin, Equals und GetHash zu überschreiben, um dies zu handhaben (siehe Frage zum Stapelüberlauf. Dieser Code gibt unterschiedliche Werte zurück. Ich möchte jedoch eine stark typisierte Sammlung im Gegensatz zu zurückgeben ein anonymer Typ ), aber wenn Sie etwas benötigen, das im gesamten Code allgemein gehalten ist, sind die Lösungen in diesem Artikel großartig.

List<Person>lst=new List<Person>
        var result1 = lst.OrderByDescending(a => a.ID).Select(a =>new Player {ID=a.ID,Name=a.Name} ).Distinct();

Überschreibung equals (Objekt obj) und GetHashCode () Methode:

class Person
{
    public int Id { get; set; }
    public int Name { get; set; }

    public override bool Equals(object obj)
    {
        return ((Person)obj).Id == Id;
        // or: 
        // var o = (Person)obj;
        // return o.Id == Id && o.Name == Name;
    }
    public override int GetHashCode()
    {
        return Id.GetHashCode();
    }
}

und dann einfach anrufen:

List<Person> distinctList = new[] { person1, person2, person3 }.Distinct().ToList();

Sie sollten in der Lage sein, Equals on person zu überschreiben, um Equals on Person.id tatsächlich auszuführen. Dies sollte zu dem Verhalten führen, nach dem Sie suchen.

Bitte versuchen Sie es mit dem folgenden Code.

var Item = GetAll().GroupBy(x => x .Id).ToList();