තේරීම සහ තේරීම අතර වෙනස

Selectසහ අතර වෙනස මම සෙව්වෙමිSelectMany නමුත් මම සුදුසු පිළිතුරක් සොයා ගැනීමට හැකි වී නැත. LINQ To SQL භාවිතා කරන විට මට වෙනස ඉගෙන ගත යුතු නමුත් මා සොයාගෙන ඇත්තේ සම්මත අරා උදාහරණ පමණි.

SQL උදාහරණයකට යමෙකුට LINQ ලබා දිය හැකිද?

SelectManyලැයිස්තු ලැයිස්තුවක් ලබා දෙන විමසුම් සමතලා කරයි. උදාහරණයක් වශයෙන්

public class PhoneNumber
{
    public string Number { get; set; }
}

public class Person
{
    public IEnumerable<PhoneNumber> PhoneNumbers { get; set; }
    public string Name { get; set; }
}

IEnumerable<Person> people = new List<Person>();

// Select gets a list of lists of phone numbers
IEnumerable<IEnumerable<PhoneNumber>> phoneLists = people.Select(p => p.PhoneNumbers);

// SelectMany flattens it to just a list of phone numbers.
IEnumerable<PhoneNumber> phoneNumbers = people.SelectMany(p => p.PhoneNumbers);

// And to include data from the parent in the result: 
// pass an expression to the second parameter (resultSelector) in the overload:
var directory = people
   .SelectMany(p => p.PhoneNumbers,
               (parent, child) => new { parent.Name, child.Number });

.NET Fiddle හි සජීවී නිරූපණය

බොහෝ දේ තෝරන්න යනු හරස් නිෂ්පාදනයක් ගන්නා SQL හි හරස් සම්බන්ධ වීමේ මෙහෙයුම වැනි ය .
උදාහරණයක් ලෙස අපට තිබේ නම්

Set A={a,b,c}
Set B={x,y}

පහත දැක්වෙන කට්ටලය ලබා ගැනීම සඳහා බොහෝ දේ තෝරා ගත හැකිය

{ (x,a) , (x,b) , (x,c) , (y,a) , (y,b) , (y,c) }

මෙහිදී අපි A කට්ටලයේ මූලද්‍රව්‍යයන්ගෙන් සෑදිය හැකි සහ සංයෝජනය කළ හැකි සියලුම සංයෝජන ලබා ගනිමු.

මෙන්න ඔබට උත්සාහ කළ හැකි LINQ උදාහරණයක්

List<string> animals = new List<string>() { "cat", "dog", "donkey" };
List<int> number = new List<int>() { 10, 20 };

var mix = number.SelectMany(num => animals, (n, a) => new { n, a });

මිශ්‍රණයට පැතලි ව්‍යුහයේ පහත සඳහන් අංග ඇත

{(10,cat), (10,dog), (10,donkey), (20,cat), (20,dog), (20,donkey)}

var players = db.SoccerTeams.Where(c => c.Country == "Spain")
                            .SelectMany(c => c.players);

foreach(var player in players)
{
    Console.WriteLine(player.LastName);
}

1. ඩි ජියා
2. ඇල්බා
3. කොස්ටා
4. විලා
5. බුස්කට්

...

SelectMany() තත්පරයක් අවශ්‍ය වන ආකාරයට බහුවිධ අනුක්‍රමයක් බිඳ දැමීමට ඔබට ඉඩ සලසයි Select() හෝ ලූපයකට .

වැඩි විස්තර මෙම බ්ලොග් සටහනේ .

වෙත අධි බර කිහිපයක් තිබේ SelectMany . ඔවුන්ගෙන් එක් අයෙකු ධූරාවලිය හරහා ගමන් කරන අතරතුර දෙමව්පියන් සහ දරුවන් අතර ඇති ඕනෑම සම්බන්ධතාවයක් සොයා ගැනීමට ඔබට ඉඩ සලසයි.

උදාහරණය : ඔබට පහත ව්‍යුහය ඇතැයි සිතමු:League -> Teams -> Player .

ඔබට පහසුවෙන් ක්‍රීඩකයන්ගේ පැතලි එකතුවක් ආපසු ලබා දිය හැකිය. කෙසේ වෙතත් ක්‍රීඩකයා සිටින කණ්ඩායම පිළිබඳ කිසිදු සඳහනක් ඔබට අහිමි විය හැකිය.

වාසනාවකට මෙන් එවැනි කාර්යයක් සඳහා අධික බරක් ඇත:

var teamsAndTheirLeagues = 
         from helper in leagues.SelectMany
               ( l => l.Teams
                 , ( league, team ) => new { league, team } )
                      where helper.team.Players.Count > 2 
                           && helper.league.Teams.Count < 10
                           select new 
                                  { LeagueID = helper.league.ID
                                    , Team = helper.team 
                                   };

පෙර උදාහරණය ඩෑන්ගේ අයිකේ බ්ලොග් අඩවියෙන් ලබාගෙන ඇත. ඔබ එය දෙස බලන ලෙස මම තරයේ නිර්දේශ කරමි.

SelectManyසම්බන්ධ වීමේ කෙටිමඟක් මෙන් වැඩ කිරීමට මට වැටහේ .

එබැවින් ඔබට:

var orders = customers
             .Where(c => c.CustomerName == "Acme")
             .SelectMany(c => c.Orders);

තේරීම යනු ප්‍රභව මූලද්‍රව්‍යයේ සිට ප්‍රති result ල මූලද්‍රව්‍යයක් දක්වා වූ එකින් එක ප්‍රක්ෂේපණයකි. තෝරන්න- විමසුම් ප්‍රකාශනයක වගන්ති වලින් බහුවිධ ඇති විට බොහෝ දේ භාවිතා වේ: මුල් අනුක්‍රමයේ සෑම අංගයක්ම නව අනුක්‍රමයක් ජනනය කිරීම සඳහා යොදා ගනී.

සමහර SelectMany අවශ්‍ය නොවනු ඇත. විමසුම් 2 ට පහළින් එකම ප්‍රති .ලය ලබා දේ.

Customers.Where(c=>c.Name=="Tom").SelectMany(c=>c.Orders)

Orders.Where(o=>o.Customer.Name=="Tom")

1 සිට බොහෝ සම්බන්ධතා සඳහා,

1. "1" සිට ආරම්භ කරන්න, SelectMany අවශ්‍ය නම්, එය බොහෝ දේ සමතලා කරයි.
2. "බොහෝ" වලින් ආරම්භ කරන්නේ නම්, SelectMany අවශ්‍ය නොවේ. ( තවමත් "1" වෙතින් පෙරීමට හැකිය , එසේම මෙය සම්මත සම්බන්ධ විමසුමට වඩා සරල ය)

from o in Orders
join c in Customers on o.CustomerID equals c.ID
where c.Name == "Tom"
select o

මෙම SelectMany () ක්රමය යොදා නැතත් අනුක්රමයේ අංග එක් එක් වෙනම දෙයක් වන අනුක්රමයක්.

මට මේ userවගේ පන්තියක් තියෙනවා

class User
    {
        public string UserName { get; set; }
        public List<string> Roles { get; set; }
    }

ප්‍රධාන:

var users = new List<User>
            {
                new User { UserName = "Reza" , Roles = new List<string>{"Superadmin" } },
                new User { UserName = "Amin" , Roles = new List<string>{"Guest","Reseption" } },
                new User { UserName = "Nima" , Roles = new List<string>{"Nurse","Guest" } },
            };

var query = users.SelectMany(user => user.Roles, (user, role) => new { user.UserName, role });

foreach (var obj in query)
{
    Console.WriteLine(obj);
}
//output

//{ UserName = Reza, role = Superadmin }
//{ UserName = Amin, role = Guest }
//{ UserName = Amin, role = Reseption }
//{ UserName = Nima, role = Nurse }
//{ UserName = Nima, role = Guest }

ඔබට ඕනෑම අනුක්‍රමයක මෙහෙයුම් භාවිතා කළ හැකිය

int[][] numbers = {
                new[] {1, 2, 3},
                new[] {4},
                new[] {5, 6 , 6 , 2 , 7, 8},
                new[] {12, 14}
            };

IEnumerable<int> result = numbers
                .SelectMany(array => array.Distinct())
                .OrderBy(x => x);

//output

//{ 1, 2 , 2 , 3, 4, 5, 6, 7, 8, 12, 14 }

 List<List<int>> numbers = new List<List<int>> {
                new List<int> {1, 2, 3},
                new List<int> {12},
                new List<int> {5, 6, 5, 7},
                new List<int> {10, 10, 10, 12}
            };

 IEnumerable<int> result = numbers
                .SelectMany(list => list)
                .Distinct()
                .OrderBy(x=>x);

//output

// { 1, 2, 3, 5, 6, 7, 10, 12 }

ඕනෑවට වඩා තාක්‍ෂණික නොවී - බොහෝ සංවිධාන සමඟ දත්ත සමුදාය, එක් එක් බොහෝ පරිශීලකයින් සමඟ: -

var orgId = "123456789";

var userList1 = db.Organizations
                   .Where(a => a.OrganizationId == orgId)
                   .SelectMany(a => a.Users)
                   .ToList();

var userList2 = db.Users
                   .Where(a => a.OrganizationId == orgId)
                   .ToList();

දෙකම නැවත එම තෝරාගත් සංවිධානය සඳහා යෙදුම් පරිශීලක ලැයිස්තුව නැවත ලබා දේ.

සංවිධානයේ සිට පරිශීලකයින් දක්වා පළමු "ව්‍යාපෘති", දෙවැන්න පරිශීලකයින්ගේ වගුව කෙලින්ම විමසයි.

විමසුම මඟින් නූලක් (වර්‍ග මාලාවක්) ලබා දෙන විට එය වඩාත් පැහැදිලි වේ:

උදාහරණයක් ලෙස 'පලතුරු' ලැයිස්තුවේ 'ඇපල්' තිබේ නම්

'තෝරන්න' නූල නැවත ලබා දෙයි:

Fruits.Select(s=>s) 

[0]: "apple"

'SelectMany' නූල සමතලා කරයි:

Fruits.SelectMany(s=>s)

[0]: 97  'a'
[1]: 112 'p'
[2]: 112 'p'
[3]: 108 'l'
[4]: 101 'e'

එහි සමහර ක්‍රියාකාරී ක්‍රමලේඛකයන්ට උදව් කළ හැකි විකල්ප දර්ශනයක් සඳහා:

• Select වේ map
• SelectManyවන bind(හෝ flatMapඔබේ Scala / Kotlin ජනතාව සඳහා)

මෙම උදාහරණය සලකා බලන්න:

        var array = new string[2]
        {
            "I like what I like",
            "I like what you like"
        };
        //query1 returns two elements sth like this:
        //fisrt element would be array[5]  :[0] = "I" "like" "what" "I" "like"
        //second element would be array[5] :[1] = "I" "like" "what" "you" "like"
        IEnumerable<string[]> query1 = array.Select(s => s.Split(' ')).Distinct();

        //query2 return back flat result sth like this :
        // "I" "like" "what" "you"
        IEnumerable<string> query2 = array.SelectMany(s => s.Split(' ')).Distinct();

ඔබ දකින පරිදි "I" හෝ "like" වැනි අනුපිටපත් විමසුම් 2 වෙතින් ඉවත් කර ඇති නිසා "SelectMany" සමතලා කර විවිධ අනුක්‍රමයන් හරහා ව්‍යාපෘති කරයි. නමුත් query1 මඟින් නූල් අරා අනුක්‍රමය ලබා දෙයි. විමසුම් 1 හි (පළමු හා දෙවන මූලද්‍රව්‍යය) වෙනස් අරා දෙකක් ඇති බැවින් කිසිවක් ඉවත් නොකෙරේ.

උප අරා වස්තු දත්ත සමුච්චය කිරීම සඳහා SelectMany + Select භාවිතා කළ හැකි ආකාරය පිළිබඳ තවත් එක් උදාහරණයක්.

අපට දුරකථන භාවිතා කරන්නන් සිටී යැයි සිතමු:

class Phone { 
    public string BasePart = "555-xxx-xxx"; 
}

class User { 
    public string Name = "Xxxxx";
    public List<Phone> Phones; 
}

දැන් අපි සියලු පරිශීලකයින්ගේ සියලුම දුරකථන වල මූලික කොටස් තෝරා ගත යුතුය:

var usersArray = new List<User>(); // array of arrays
List<string> allBaseParts = usersArray.SelectMany(ua => ua.Phones).Select(p => p.BasePart).ToList();

පරීක්ෂා කිරීම සඳහා ආරම්භක කුඩා එකතුවක් සහිත කේත උදාහරණයක් මෙන්න:

class Program
{
    static void Main(string[] args)
    {
        List<Order> orders = new List<Order>
        {
            new Order
            {
                OrderID = "orderID1",
                OrderLines = new List<OrderLine>
                {
                    new OrderLine
                    {
                        ProductSKU = "SKU1",
                        Quantity = 1
                    },
                    new OrderLine
                    {
                        ProductSKU = "SKU2",
                        Quantity = 2
                    },
                    new OrderLine
                    {
                        ProductSKU = "SKU3",
                        Quantity = 3
                    }
                }
            },
            new Order
            {
                OrderID = "orderID2",
                OrderLines = new List<OrderLine>
                {
                    new OrderLine
                    {
                        ProductSKU = "SKU4",
                        Quantity = 4
                    },
                    new OrderLine
                    {
                        ProductSKU = "SKU5",
                        Quantity = 5
                    }
                }
            }
        };

        //required result is the list of all SKUs in orders
        List<string> allSKUs = new List<string>();

        //With Select case 2 foreach loops are required
        var flattenedOrdersLinesSelectCase = orders.Select(o => o.OrderLines);
        foreach (var flattenedOrderLine in flattenedOrdersLinesSelectCase)
        {
            foreach (OrderLine orderLine in flattenedOrderLine)
            {
                allSKUs.Add(orderLine.ProductSKU);
            }
        }

        //With SelectMany case only one foreach loop is required
        allSKUs = new List<string>();
        var flattenedOrdersLinesSelectManyCase = orders.SelectMany(o => o.OrderLines);
        foreach (var flattenedOrderLine in flattenedOrdersLinesSelectManyCase)
        {
            allSKUs.Add(flattenedOrderLine.ProductSKU);
        }

       //If the required result is flattened list which has OrderID, ProductSKU and Quantity,
       //SelectMany with selector is very helpful to get the required result
       //and allows avoiding own For loops what according to my experience do code faster when
       // hundreds of thousands of data rows must be operated
        List<OrderLineForReport> ordersLinesForReport = (List<OrderLineForReport>)orders.SelectMany(o => o.OrderLines,
            (o, ol) => new OrderLineForReport
            {
                OrderID = o.OrderID,
                ProductSKU = ol.ProductSKU,
                Quantity = ol.Quantity
            }).ToList();
    }
}
class Order
{
    public string OrderID { get; set; }
    public List<OrderLine> OrderLines { get; set; }
}
class OrderLine
{
    public string ProductSKU { get; set; }
    public int Quantity { get; set; }
}
class OrderLineForReport
{
    public string OrderID { get; set; }
    public string ProductSKU { get; set; }
    public int Quantity { get; set; }
}

මෙම SelectManyකඩා ක්රමය ඉනිමත් සමග IEnumerable<IEnumerable<T>>තුලට IEnumerable<T>, කොමියුනිස්ට්වාදය වැනි, සෑම අංගයක් ආකාරයට (මෝඩ යකා genious එක් සමාන අයිතිවාසිකම් ඇති) ලෙස හැසිරී ඇත.

var words = new [] { "a,b,c", "d,e", "f" };
var splitAndCombine = words.SelectMany(x => x.Split(','));
// returns { "a", "b", "c", "d", "e", "f" }

මා සිතන දේ තේරුම් ගැනීමට හොඳම ක්‍රමය එයයි.

            var query =
            Enumerable
                .Range(1, 10)
                .SelectMany(ints => Enumerable.Range(1, 10), (a, b) => $"{a} * {b} = {a * b}")
                .ToArray();

        Console.WriteLine(string.Join(Environment.NewLine, query));

        Console.Read();

ගුණ කිරීමේ වගු උදාහරණය.