Wählen Sie unter Verwendung von LINQ in C # eindeutige Werte aus einer Liste aus.

Habe ich eine Sammlung von Employee -

Class Employee

{
  empName
  empID
  empLoc 
  empPL
  empShift
}

Meine Liste enthält

 empName,empID,empLoc,empPL,empShift
    E1,1,L1,EPL1,S1 
    E2,2,L2,EPL2,S2
    E3,3,L3,EPL3,S3
    E4,4,L1,EPL1,S1
    E5,5,L5,EPL5,S5
        E6,6,L2,EPL2,S2

Ich brauchen, um die Mitarbeiter mit unterschiedlichen Werten
empLoc,empPL,empShift.

Gibt es irgendeinen Weg dies zu erreichen ist die Verwendung von LINQ ?

Kommentar zu dem Problem - Öffnen

Sie benötigen den ganzen Informationen für alle Mitarbeiter, oder nur die empLoc, empPL und empShirt? (Ihre Benennung ist ziemlich böse, da Sie in eine Employee-Klasse, die "emp" als Vorsilbe ist überflüssig, aber "Loc" und "PL" relativ bedeutungslos auf Ihrer eigenen.) Kommentarautor: Jon Skeet

@JonSkeet dies ist die Grundvoraussetzung. Ich habe gerade eine Klasse. Aber im original ist es mit viel der Eigenschaften und alles, was ich brauchen, ist zu prüfen, - 3-Eigenschaften.Ich m tut mir Leid 🙁 . Ich brauche die ganzen Informationen . Nicht nur empLoc, empPL und empShift . Kommentarautor: kbvishnu

Sie DistinctBy von morelinq mit einem zusammengesetzten Schlüssel (anonymous Typ)? Kommentarautor: devdigital

InformationsquelleAutor der Frage kbvishnu | 2012-09-25

.net c#linq

Könnten Sie bei der Implementierung einer benutzerdefinierten , IEqualityComparer<Mitarbeiter - >:

public class Employee
{
    public string empName { get; set; }
    public string empID { get; set; }
    public string empLoc { get; set; }
    public string empPL { get; set; }
    public string empShift { get; set; }

    public class Comparer : IEqualityComparer<Employee>
    {
        public bool Equals(Employee x, Employee y)
        {
            return x.empLoc == y.empLoc
                && x.empPL == y.empPL
                && x.empShift == y.empShift;
        }

        public int GetHashCode(Employee obj)
        {
            unchecked  //overflow is fine
            {
                int hash = 17;
                hash = hash * 23 + (obj.empLoc ?? "").GetHashCode();
                hash = hash * 23 + (obj.empPL ?? "").GetHashCode();
                hash = hash * 23 + (obj.empShift ?? "").GetHashCode();
                return hash;
            }
        }
    }
}

Nun können Sie mit dieser überladung der Enumerable.Distinct:

var distinct = employees.Distinct(new Employee.Comparer());

Weniger wiederverwendbare, robuste und effiziente Vorgehensweise, mit Hilfe eines anonymen Typ:

var distinctKeys = employees.Select(e => new { e.empLoc, e.empPL, e.empShift })
                            .Distinct();
var joined = from e in employees
             join d in distinctKeys
             on new { e.empLoc, e.empPL, e.empShift } equals d
             select e;
//if you want to replace the original collection
employees = joined.ToList();

InformationsquelleAutor der Antwort Tim Schmelter

Können Sie GroupBy mit anonymen Typ, und dann bekommen First:

list.GroupBy(e => new { 
                          empLoc = e.empLoc, 
                          empPL = e.empPL, 
                          empShift = e.empShift 
                       })

    .Select(g => g.First());

InformationsquelleAutor der Antwort Cuong Le

Können Sie versuchen, mit diesem code

var result =  (from  item in List
              select new 
              {
                 EmpLoc = item.empLoc,
                 EmpPL= item.empPL,
                 EmpShift= item.empShift
              })
              .ToList()
              .Distinct();

InformationsquelleAutor der Antwort Aghilas Yakoub

Ich war neugierig, welche Methode wäre schneller:

Unter Verwendung von Distinct mit einem benutzerdefinierten IEqualityComparer oder
Mit der GroupBy-Methode beschrieben von Cuong Le.

Fand ich, dass, abhängig von der Größe der Eingabe-Daten und die Anzahl der Gruppen, die Distinct-Methode kann eine Menge mehr performant. (als die Anzahl der Gruppen tendenziell die Anzahl der Elemente in der Liste, deutliche schneller läuft).

Code läuft in LinqPad!

    void Main()
    {
        List<C> cs = new List<C>();
        foreach(var i in Enumerable.Range(0,Int16.MaxValue*1000))
        {
            int modValue = Int16.MaxValue; //vary this value to see how the size of groups changes performance characteristics. Try 1, 5, 10, and very large numbers
            int j = i%modValue; 
            cs.Add(new C{I = i, J = j});
        }
        cs.Count ().Dump("Size of input array");

        TestGrouping(cs);
        TestDistinct(cs);
    }

    public void TestGrouping(List<C> cs)
    {
        Stopwatch sw = Stopwatch.StartNew();
        sw.Restart();
        var groupedCount  = cs.GroupBy (o => o.J).Select(s => s.First()).Count();
        groupedCount.Dump("num groups");
        sw.ElapsedMilliseconds.Dump("elapsed time for using grouping");
    }

    public void TestDistinct(List<C> cs)
    {
        Stopwatch sw = Stopwatch.StartNew();
        var distinctCount = cs.Distinct(new CComparerOnJ()).Count ();
        distinctCount.Dump("num distinct");
        sw.ElapsedMilliseconds.Dump("elapsed time for using distinct");
    }

    public class C
    {
        public int I {get; set;}
        public int J {get; set;}
    }

    public class CComparerOnJ : IEqualityComparer<C>
    {
        public bool Equals(C x, C y)
        {
            return x.J.Equals(y.J);
        }

        public int GetHashCode(C obj)
        {
            return obj.J.GetHashCode();
        }
    }

InformationsquelleAutor der Antwort Raj Rao

Versuchen,

var newList = 
(
from x in empCollection
select new {Loc = x.empLoc, PL = x.empPL, Shift = x.empShift}
).Distinct();

InformationsquelleAutor der Antwort John Woo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.