LINQ හි ​​කණ්ඩායම් කරන්න

අපට මෙවැනි පංතියක් තිබේ යැයි සිතමු:

class Person { 
    internal int PersonID; 
    internal string car; 
}

මට මෙම පන්තියේ ලැයිස්තුවක් ඇත: List<Person> persons;

මෙම ලැයිස්තුවට එකම PersonIDs සමඟ බහුවිධ අවස්ථා තිබිය හැක , උදාහරණයක් ලෙස:

persons[0] = new Person { PersonID = 1, car = "Ferrari" }; 
persons[1] = new Person { PersonID = 1, car = "BMW"     }; 
persons[2] = new Person { PersonID = 2, car = "Audi"    }; 

මට කණ්ඩායම්ගත වී PersonIDඔහු සතුව ඇති සියලුම මෝටර් රථ ලැයිස්තුව ලබා ගත හැකි ක්‍රමයක් තිබේද?

උදාහරණයක් ලෙස, අපේක්ෂිත ප්‍රති result ලය වනු ඇත

class Result { 
   int PersonID;
   List<string> cars; 
}

එබැවින් කණ්ඩායම් කිරීමෙන් පසුව, මට ලැබෙනුයේ:

results[0].PersonID = 1; 
List<string> cars = results[0].cars; 

result[1].PersonID = 2; 
List<string> cars = result[1].cars;

මා මෙතෙක් කර ඇති දෙයින්:

var results = from p in persons
              group p by p.PersonID into g
              select new { PersonID = g.Key, // this is where I am not sure what to do

කරුණාකර යමෙකුට මාව නිවැරදි දිශාවට යොමු කළ හැකිද?

නියත වශයෙන්ම - ඔබට මූලික වශයෙන් අවශ්‍ය වන්නේ:

var results = from p in persons
              group p.car by p.PersonId into g
              select new { PersonId = g.Key, Cars = g.ToList() };

හෝ විමසුම් නොවන ප්‍රකාශනයක් ලෙස:

var results = persons.GroupBy(
    p => p.PersonId, 
    p => p.car,
    (key, g) => new { PersonId = key, Cars = g.ToList() });

මූලික වශයෙන් කණ්ඩායමේ අන්තර්ගතය (අ ලෙස සලකන විට ) ලබා දී ඇති යතුර සඳහා IEnumerable<T>ප්‍රක්ෂේපණයේ ( p.carමේ අවස්ථාවේ දී) ඇති ඕනෑම අගයක අනුක්‍රමයකි .

GroupByක්‍රියා කරන ආකාරය පිළිබඳ වැඩි විස්තර සඳහා , මාතෘකාව පිළිබඳ මගේ එඩුලින්ක් ලිපිය බලන්න .

( .NET නම් කිරීමේ සම්මුතීන් අනුගමනය කිරීම සඳහා මම ඉහත නම් PersonIDකර PersonIdඇත .)

විකල්පයක් ලෙස, ඔබට මෙය භාවිතා කළ හැකිය Lookup:

var carsByPersonId = persons.ToLookup(p => p.PersonId, p => p.car);

එවිට ඔබට එක් එක් පුද්ගලයා සඳහා කාර් ඉතා පහසුවෙන් ලබා ගත හැකිය:

// This will be an empty sequence for any personId not in the lookup
var carsForPerson = carsByPersonId[personId];

var results = from p in persons
              group p by p.PersonID into g
              select new { PersonID = g.Key,
                           /**/car = g.Select(g=>g.car).FirstOrDefault()/**/}

var results = from p in persons
              group p by p.PersonID into g
              select new { PersonID = g.Key, Cars = g.Select(m => m.car) };

ඔබට මෙය උත්සාහ කළ හැකිය:

var results= persons.GroupBy(n => new { n.PersonId, n.car})
                .Select(g => new {
                               g.Key.PersonId,
                               g.Key.car)}).ToList();

උත්සාහ කරන්න

persons.GroupBy(x => x.PersonId).Select(x => x)

හෝ

ඔබගේ ලැයිස්තුවේ කිසියම් පුද්ගලයෙක් පුනරාවර්තනය වන්නේ දැයි පරීක්ෂා කිරීමට උත්සාහ කරන්න

persons.GroupBy(x => x.PersonId).Where(x => x.Count() > 1).Any(x => x)

විමසුම් සින්ටැක්ස් සහ ක්‍රම සින්ටැක්ස් සමඟ වැඩකරන කේත නියැදියක් මම නිර්මාණය කර ඇත්තෙමි. එය අනෙක් අයට උපකාරී වේ යැයි මම බලාපොරොත්තු වෙමි :)

ඔබට .Net Fiddle හි කේතය ක්‍රියාත්මක කළ හැකිය:

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

class Person
{ 
    public int PersonId; 
    public string car  ; 
}

class Result
{ 
   public int PersonId;
   public List<string> Cars; 
}

public class Program
{
    public static void Main()
    {
        List<Person> persons = new List<Person>()
        {
            new Person { PersonId = 1, car = "Ferrari" },
            new Person { PersonId = 1, car = "BMW" },
            new Person { PersonId = 2, car = "Audi"}
        };

        //With Query Syntax

        List<Result> results1 = (
            from p in persons
            group p by p.PersonId into g
            select new Result()
                {
                    PersonId = g.Key, 
                    Cars = g.Select(c => c.car).ToList()
                }
            ).ToList();

        foreach (Result item in results1)
        {
            Console.WriteLine(item.PersonId);
            foreach(string car in item.Cars)
            {
                Console.WriteLine(car);
            }
        }

        Console.WriteLine("-----------");

        //Method Syntax

        List<Result> results2 = persons
            .GroupBy(p => p.PersonId, 
                     (k, c) => new Result()
                             {
                                 PersonId = k,
                                 Cars = c.Select(cs => cs.car).ToList()
                             }
                    ).ToList();

        foreach (Result item in results2)
        {
            Console.WriteLine(item.PersonId);
            foreach(string car in item.Cars)
            {
                Console.WriteLine(car);
            }
        }
    }
}

ප්රති result ලය මෙන්න:

1
ෆෙරාරි
BMW
2
අවී
-----------
1
ෆෙරාරි
BMW
2
අවී

මේක උත්සාහ කරන්න :

var results= persons.GroupBy(n => n.PersonId)
            .Select(g => new {
                           PersonId=g.Key,
                           Cars=g.Select(p=>p.car).ToList())}).ToList();

නමුත් කාර්ය සාධනය අනුව පහත දැක්වෙන පුහුණුව වඩා හොඳ සහ මතක භාවිතයේදී වඩාත් ප්‍රශස්ත වේ (අපගේ අරාවෙහි මිලියන ගණනක් වැනි තවත් අයිතම අඩංගු වන විට):

var carDic=new Dictionary<int,List<string>>();
for(int i=0;i<persons.length;i++)
{
   var person=persons[i];
   if(carDic.ContainsKey(person.PersonId))
   {
        carDic[person.PersonId].Add(person.car);
   }
   else
   {
        carDic[person.PersonId]=new List<string>(){person.car};
   }
}
//returns the list of cars for PersonId 1
var carList=carDic[1];

මෙය සිදු කිරීම සඳහා විකල්ප ක්‍රමයක් වන්නේ වෙනම තෝරාගෙන PersonIdකණ්ඩායම් සමඟ සම්බන්ධ වීම persons:

var result = 
    from id in persons.Select(x => x.PersonId).Distinct()
    join p2 in persons on id equals p2.PersonId into gr // apply group join here
    select new 
    {
        PersonId = id,
        Cars = gr.Select(x => x.Car).ToList(),
    };

හෝ චතුර කථික API සින්ටැක්ස් සමඟ සමාන වේ:

var result = persons.Select(x => x.PersonId).Distinct()
    .GroupJoin(persons, id => id, p => p.PersonId, (id, gr) => new
    {
        PersonId = id,
        Cars = gr.Select(x => x.Car).ToList(),
    });

GroupJoin පළමු ලැයිස්තුවේ ඇතුළත් කිරීම් ලැයිස්තුවක් නිෂ්පාදනය කරයි ( PersonIdඅපගේ නඩුවේ ලැයිස්තුව ), එක් එක් දෙවන ලැයිස්තුවට සම්බන්ධ වූ ඇතුළත් කිරීම් සමූහයක් (ලැයිස්තුව persons).

පහත දැක්වෙන උදාහරණය මඟින් කාණ්ඩගත කරන ලද වස්තු ආපසු ලබා දීමට GroupBy ක්‍රමය භාවිතා කරයි PersonID.

var results = persons.GroupBy(x => x.PersonID)
              .Select(x => (PersonID: x.Key, Cars: x.Select(p => p.car).ToList())
              ).ToList();

හෝ

 var results = persons.GroupBy(
               person => person.PersonID,
               (key, groupPerson) => (PersonID: key, Cars: groupPerson.Select(x => x.car).ToList()));

හෝ

 var results = from person in persons
               group person by person.PersonID into groupPerson
               select (PersonID: groupPerson.Key, Cars: groupPerson.Select(x => x.car).ToList());

නැතහොත් ඔබට ToLookupමූලික වශයෙන් ToLookupභාවිතා කළ හැකිය. EqualityComparer<TKey>යතුරු සංසන්දනය කිරීමට සහ කණ්ඩායම් අනුව සහ ශබ්ද කෝෂයට භාවිතා කරන විට ඔබ අතින් කළ යුතු දේ කරන්න. මම හිතන්නේ එය අනුමත කිරීමක් නොවේ

 ILookup<int, string> results = persons.ToLookup(
            person => person.PersonID,
            person => person.car);

පළමුව, ඔබේ යතුරු ක්ෂේත්‍රය සකසන්න. ඉන්පසු ඔබේ වෙනත් ක්ෂේත්‍ර ඇතුළත් කරන්න:

var results = 
    persons
    .GroupBy(n => n.PersonId)
    .Select(r => new Result {PersonID = r.Key, Cars = r.ToList() })
    .ToList()