LINQ Query Expressions

C# in Hindiये Article इस वेबसाईट पर Selling हेतु उपलब्‍ध EBook C#.NET in Hindi से लिया गया है। इसलिए यदि ये Article आपके लिए उपयोगी रहा, तो निश्चित रूप से ये पुस्तक भी आपके लिए काफी उपयोगी साबित होगी। 

C#.NET in Hindi | Page:908 | Format: PDF

BUY NOW DOWNLOAD READ ONLINE

LINQ Query Expression में हम कई Contextual Keywords या Clauses को Use कर सकते हैं, जो कि ठीक उसी तरह से LION Query Create करने के लिए Use होते हैं, जिस तरह से SQL Queries में Use होते हैं।

Query Expression में हम जिन Clauses को Use करते हैं, उन्हें उसी क्रम में Use करना जरूरी होता है, जिस क्रम में Use किया जाना चाहिए। क्योंकि Internally सभी LINQ Clauses वास्तव में एक प्रकार के Extension Methods हैं।

किसी भी Query Expression में हमेंशा from select/group Clause को Compulsory रूप से Specify करना जरूरी होता है, जबकि अन्‍य Clauses को Optional तरीके से Use किया जाता है। Query Expression में select Clause से ही Query का अन्त होता है, जबकि सामान्‍य SQL Language में select Clause से Query की शुरूआत होती है।

LINQ Query Expressions – from Clause

from Clause उस Data Collection को Specify करता है, जिसका प्रयोग Data Source के रूप में किया जाना होता है। साथ ही इस Clause के साथ हमें एक Iteration Variable को भी Specify करना होता है। Iteration Variable, Query Fire होने पर Generate होने वाले Result-Set के एक-एक Item को Sequentially Represent करता है।

जब Specified Query Fire होता है, तब जो Selected Results Generate होते हैं, उन सभी Generated Returned Items के Group को Collection के नाम से जाना जाता है। जबकि सरल शब्दों में कहें तो Query Variable को ही एक प्रकार से Collection Object की तरह foreach Loop में उपयोग में लिया जाता है। from Clause के साथ Iteration Variable Data Source को निम्नानुसार तरीके से Use किया जाता है:

LINQ Query Expressions - Hindi

LINQ Query Expressions – Hindi

जहां Item उस Data Source के Item के Type का है, जिस पर LINQ Query को Fire करना है, जबकि Items उस Data Source का नाम है। जैसे:

int[] numbers = { 12, 50, 28, 23, 45 };
var items = from item in numbers . . .

इस Code Segment में numbers नाम का Integer Type का Array हमारे LINQ Query का Data Source है और item वह Iterator Variable है, जिसमें numbers नाम के Array से Return होने वाला Item One by One Sequentially Store होगा।

select Clause

select Clause इस बात को तय करता है कि Query द्वारा Return होने वाला Element या Item का Type क्या होगा। सामान्‍यत: इस Clause का Syntax निम्नानुसार होता है:

. . . select Expression;
or
. . . group Expression;

जहां select Clause के साथ Specified Expression, Data Source से Return होने वाले Iteration Variable या Range Variable को Represent करता है। select Clause के स्थान पर हम group Clause को भी Use कर सकते हैं, जो कि SQL के GROUP BY Clause के समान काम करते हुए Group Result Generate करता है।

हालांकि इसका प्रयोग Range Variable के एक Specific Portion को Represent करने के लिए भी किया जा सकता है। या फिर हम इसके Expression के रूप में किसी Range Variable के लिए Generated Values के आधार पर कोई Anonymous Type Construct कर सकते हैं।

select Clause को Specify करके हम ये तय करते हैं कि Data Source के किस Part को Select किया जाना चाहिए। सामान्‍यत: select Clause SQL के SELECT Clause के समान ही होता है, जो Data Source यानी Table से Return होने वाले Data का Selection तय करता है।

चूंकि किसी भी LINQ Query में fromselect Clause को Compulsory रूप से Use करना जरूरी होता है, इसलिए यदि हम हमारे पिछले Code Segment को ही from select Clause के माध्‍यम से पूरा करें, तो हमारा Statement कुछ निम्नानुसार बनेगा:

int[] numbers = { 12, 50, 28, 23, 45 };
var items = from item in numbers select item;

यदि हम इस Code Segment में Specified numbers नाम के Array को एक Relational Database की Table मान लें और item को उस Table का एक Field मान लें, तो इसी LINQ Query को SQL Query में Convert करने पर हमारी SQL Query कुछ निम्नानुसार बनेगी:

SELECT item FROM numbers;

जबकि यदि हम हर Single Value को एक अलग Variable में Store करना चाहते, है, तब हम इसी SQL Statement में AS Clause को निम्नानुसार तरीके से भी Use करते हैं:

SELECT item FROM item AS numbers;

जो कि Exactly हमारे LINQ Query के समान ही है, जहां यदि हम AS के स्थान पर in Specify कर दें, तो हमारा Query निम्नानुसार हो जाएगा:

SELECT item FROM item in numbers;

यानी यदि हम चाहें तो SQL Query को LINQ Query में और किसी LINQ Query को SQL Query में आसानी से Convert कर सकते हैं, जिससे हमें इन Queries के Execution को समझने में आसानी हो जाती है।

LINQ Query Using from and select Clauses Only

यदि हम चाहें तो केवल select from Clause का प्रयोग करते हुए निम्नानुसार तरीके से अपने स्वयं के बना, गए एक students नाम के Collection Array को Data Source की तरह Use करते हुए उसके सारे Elements को LINQ Query के माध्‍यम से Access कर सकते हैं:

File Name: UsingLINQWithStudentArrayCollection.cs
using System;
using System.Linq;

namespace CSharpLINQ
{
    class SimpleQuery
    {
        static void Main()
        {
            var students = new[] // Array of objects of an anonymous type
			{
				new { LName="Mishra", FName="Kuldeep", Age=31 },
				new { LName="Sharma", FName="Ramesh", Age=20 },
				new { LName="Verma", FName="Manoj", Age=21 }
			};

            var query = from student in students select student;

            foreach (var q in query)
                Console.WriteLine("Name: {0} {1}, Age: {2}", q.FName, q.LName, q.Age);
        }
    }
}

// Output:
   Name: Kuldeep Mishra, Age: 31
   Name: Ramesh Sharma, Age: 20
   Name: Manoj Verma, Age: 21

इस Program में students नाम का हमारा Array एक Data Source की तरह Treat हो रहा है, जिसमें तीन Students की Information एक Anonymous Type Object के रूप में Stored है। परिणामस्वरूप जब निम्न Statement Execute होता है:

var query = from student in students select student;

एक LINQ Query Definition query नाम के Query Variable में Assign हो जाता है, जिसे foreach Loop द्वारा निम्नानुसार Execute करने पर:

foreach (var q in query)

students नाम के हमारे Data Source से सभी Students की Information One by One Sequentially Retrieve होकर student नाम के Reference Type में Enumerate हो जाती है, जिसे foreach Statement में Variable q द्वारा Retrieve कर लिया जाता है और Output में Display कर दिया जाता है। चूंकि इस Program में हमने निम्नानुसार LINQ Query Specify किया है:

var query = from student in students select student;

इसलिए students नाम के Data Source से सभी Students की सारी Information Enumerate होकर student नाम के Reference Variable में One by One Store होता है। लेकिन यदि हम इसी LINQ Query को निम्नानुसार Modify कर दें-

var query = from student in students select student.FName;

तो हमारे इस Program का Output कुछ निम्नानुसार प्राप्त होगा:

Output:

Name: Kuldeep Mishra
Name: Ramesh Sharma
Name: Manoj Verma

क्योंकि हमने हमारे Data Source से केवल Student के FName को ही Return करने के लिए LINQ Query Specify किया है। जबकि यदि हम इसी LINQ Query को आसानी से समझने के लिए SQL Statement की तरह लिखना चाहें, तो हमारा SQL Statement कुछ निम्नानुसार होगा:

SELECT student.FName FROM student AS students;

Anonymous Types with select Clause

चूंकि जिस तरह से किसी LINQ Query से Generate होने वाले Result में Data Source से Return होने वाले Source Collections के Items या Source Collection के Items के Fields होते हैं। ठीक उसी तरह से यदि हम चाहें तो select Clause के साथ किसी Anonymous Type Object को भी Specify कर सकते हैं। जैसे:

File Name: selectClauseWithAnonymouseType.cs
using System;
using System.Linq;

namespace CSharpLINQ
{
    class SimpleQuery
    {
        static void Main()
        {
            var students = new[] // Array of objects of an anonymous type
			{
				new { LName="Mishra", FName="Kuldeep", Age=31 },
				new { LName="Sharma", FName="Ramesh", Age=20 },
				new { LName="Verma", FName="Manoj", Age=21 }
			};

            var query = from student in students select new { student.FName, student.Age };

            foreach (var q in query)
                Console.WriteLine("Name: {0}, Age: {1}", q.FName, q.Age);
        }
    }
}

// Output:
   Name: Kuldeep, Age: 31
   Name: Ramesh, Age: 20
   Name: Manoj, Age: 21

इस Program में हमने हमारी LINQ Query को निम्नानुसार तरीके से Specify किया है:

var query = from student in students select new { student.FName, student.Age };

इस LINQ Query में हमने select Clause के साथ एक Anonymous Type Object को Specify किया है, जिसकी पहली Property एक String Type Property होगी, जबकि दूसरी Property एक Integer Type Property होगी। क्योंकि पहली Property के रूप में हम एक नाम Specify कर रहे हैं, जबकि दूसरी Property के रूप में हम एक Age Specify कर रहे हैं, जो कि Numerical मान होता है।

इसलिए जब ये Query Execute होगा, तो Data Source से ऐसे Objects Return करेगा, जो कि ऐसे Anonymous Type के Object होंगे, जिनमें पहले Field का Type String व दूसरे Field का Type Integer होगा।

Nested from Clause

हम किसी LINQ Query में from Clause की Nesting भी कर सकते हैं। यानी हम एक ही LINQ Query में एक से ज्यादा बार from Clause को Use कर सकते हैं। Nested from Clause का एक Common Use ये होता है कि हम दो Different Data Source से Data Results Retrieve करने की सुविधा प्राप्त कर लेते हैं। जैसे:

File Name: fromClause-MultipleTimes.cs
using System;
using System.Linq;

namespace CSharpLINQ
{
    class SimpleQuery
    {
        static void Main()
        {
            int[] numbers1 = { 10, 20, 30 };
            int[] numbers2 = { -10, -20 };

            var posNums = from n in numbers1 from m in numbers2 select new { n, m };
            Console.WriteLine("All Combinations: ");

            // Execute the query and display the results.
            foreach (var obj in posNums)
                Console.WriteLine(obj.m + "," + obj.n);
        }
    }
}

// Output:
   All Combinations: 
   -10,10
   -20,10
   -10,20
   -20,20
   -10,30
   -20,30

जब हम किसी LINQ Query में Nested from Clause Use कर रहे होते हैं, तब हम वास्तव में SQL की Cartesian Product Query Create कर रहे होते हैं, जिसमें पहली Table के हर Record को दूसरी Table के हर Record के साथ Display किया जाता है। यदि हम इस Program में निम्नानुसार Specified LINQ Query को:

var posNums = from n in numbers1 from m in numbers2 where n > 0 select new { n, m };

SQL Query के रूप में Convert करें, तो हमारी SQL SELECT Query कुछ निम्नानुसार बन सकती है:

SELECT n, m from n AS numbers1,  m AS numbers2 WHERE  n > 0;

Nested from Clause का एक प्रयोग और होता है, जब हम किसी एक Data Source के अन्दर किसी Stored किसी दूसरे Source से Data की Query करना चाहते हैं।

where Clause

where Clause का प्रयोग करके हम किसी Data Source से Return होने वाले Items को Filter कर सकते हैं और केवल उन्हीं Items को Return करने के लिए Criteria Set कर सकते है, जो कि किसी Specific Condition को Satisfy करते हैं। where Clause के साथ हमेंशा ऐसा Expression Specify करना होता है, जो कि Boolean Value ही Return करे।

साथ ही जब हमें एक से ज्यादा Conditions के आधार पर Data Source से Returned Results की Filtering करनी होती है, तब हम LIQN Query में एक से ज्यादा बार where Clause को Use कर सकते हैं और एक से ज्यादा Conditions के लिए Data Source से Return होने वाले Data की Filtering कर सकते हैं। जैसे:

File Name: UsingMultiple-whereClause.cs
using System;
using System.Linq;

namespace CSharpLINQ
{
    class SimpleQuery
    {
        static void Main()
        {
            int[] numbers = { 1, -2, 3, -3, 0, -8, 12, 19, 6, 9, 10 };

            var query = from n in numbers where n > 0 where n < 12 select n;

            foreach (var q in query)
                Console.Write("{0}\t", q);
        }
    }
}

Output:
	1	3	6	9	10

चूंकि इस Program की LINQ Query में हमने दो where Clauses द्वारा एक Range को Specify किया है, इसलिए Output में Data Source के केवल वे ही मान Return होते हैं, जो कि 0 से बडे व 12 से छोटे हैं।

हालांकि हम LINQ Query में एक से ज्यादा where Clause को Use कर सकते हैं, लेकिन यदि हम चाहें तो पिछले Program द्वारा Generate होने वाले Result को ही निम्नानुसार LINQ Query द्वारा भी प्राप्त कर सकते हैं:

var query = from n in numbers where n > 0 && n < 12 select n;

where Clause की विशेषता ये है कि C# में हम where Clause Expression के रूप में किसी भी ऐसे Expression या Statement को Specify कर सकते हैं, जो कि Boolean Value Return करता हो और Data Source से Return होने वाले Data की जरूरत के आधार पर Filtering करते हुए Required Results Generate कर सकते हैं।

orderby Clause

orderby Clause C# के LINQ Query के लिए भी Exactly उसी प्रकार से Data Source से Returned Results को क्रम से Return करने का काम करता है, जिस तरह से SQL में ORDER BY Clause करता है, जबकि Return होने वाले Data के क्रम को तय करने के लिए हम Optionally ascending या descending Keywords को Use कर सकते हैं।

जब हम orderby Clause को Use करते हैं, तो इस Clause के साथ Specify किए जाने वाले Field का Numeric Field होना जरूरी नहीं होता। बल्कि हम किसी भी Field के आधार पर Returned Data की Ordering कर सकते हैं साथ ही हम जितनी बार चाहें उतनी बार orderby Clause को Use कर सकते हैं। जैसे:

File Name: orderbyClause.cs
using System;
using System.Linq;

namespace CSharpLINQ
{
    class SimpleQuery
    {
        static void Main()
        {
            var students = new[] // Array of objects of an anonymous type
			{
				new { LName="Mishra", FName="Kuldeep", Age=31 },
				new { LName="Sharma", FName="Ramesh", Age=20 },
				new { LName="Verma", FName="Manoj", Age=21 },
				new { LName="Mishra", FName="Rajesh", Age=45 },
				new { LName="Soni", FName="Mukesh", Age=35 },
				new { LName="Goyal", FName="Suresh", Age=15}
			};

            var query = from student in students orderby student.Age select student;

            foreach (var q in query)
                Console.WriteLine("Name: {0},  Age: {1}", q.FName, q.Age);
        }
    }
}

// Output:
   Name: Suresh,  Age: 15
   Name: Ramesh,  Age: 20
   Name: Manoj,  Age: 21
   Name: Kuldeep,  Age: 31
   Name: Mukesh,  Age: 35
   Name: Rajesh,  Age: 45

इस Program में हमने निम्नानुसार LINQ Query Specify करते हुए उसमें orderby Clause को student.Age File के साथ Specify किया है, इसलिए Returned Result Output में ।हम के Ascending Order में Display होता है:

var query = from student in students
orderby student.Age
select student;

जबकि यदि हम इसी Query को निम्नानुसार Specify कर दें-

var query = from student in students
orderby student.FName descending
select student;

हालांकि सामान्‍यत: केवल एक ही Field पर Sorting Apply किया जाता है। लेकिन यदि हम चाहें तो एक Comma Separated List के रूप में Multiple Fields पर Sorting करने के लिए Setup कर सकते हैं। जैसे:

var query = from student in students
orderby student.FName descending, student.Age
select student;

जब हम इस तरह का Statement Specify करते हैं, तो C# Compiler पहले सभी Returned Results की First Name के आधार पर Ordering करता है और फिर Age के आधार पर Ordering करता है।

group . . . by Clause

group Clause का प्रयोग करके हम किसी Specific Criteria के आधार पर Selected Objects की Grouping कर सकते हैं। ठीक उसी तरह से जिस तरह से SQL में GROUP Clause का प्रयोग किया जाता है। group Clause की सबसे महत्वपूर्ण विशेषता ये है कि हम किसी Particular Field के आधार पर Selected Result की Grouping कर सकते हैं जबकि जिस Particular Field के आधार पर Grouping की जाती है, उसे Key के नाम से जाना जाता है।

जब हम group Clause को Use करते हैं, तब Original Data Source से कोई Enumeration Return नहीं होताए बल्कि एक Enumerable Return होता है, जो Items के Group को Enumerate करने की सुविधा देता है। जबकि जो Groups Return होते हैं, वे Groups भी पूरी तरह से Enumerable होते हैं, जिनके Actual Items को Access करने के लिए उन्हें Enumerate किया जा सकता है।

यानी group Clause का प्रयोग करके हम किसी Key के According विभिन्न प्रकार के Returned Data की Grouping कर सकते हैं और उस Key से Associated सभी Items को Sequentially Retrieve किया जा सकता है।

जब हम select Clause का प्रयोग नहीं करते तब हम group Clause का प्रयोग करते हैं। यानी select या group में से कोई एक ही Clause किसी LINQ Query में हो सकता है और एक समय पर दोनों में से कोई एक ही Clause किसी LIQN Query में Exist हो सकता है, दोनों नहीं।

group Clause को Use करने पर Result के रूप में हमें IGrouping<TKey, TElement> Type के Elements का Set प्राप्त होता है, जिसे System.Linq Namespace में Define किया गया है। ये ऐसे Objects के Collection को Define करता है, जिनमें एक Common Key होता है। IGrouping एक Read-Only Property भी Define करता है, जिसे Key कहते हैं, जो कि हर Sequence के साथ Associated Key को Return करता है। group Clause को हम निम्नानुसार Use कर सकते हैं:

File Name: groupClause.cs
using System;
using System.Linq;

namespace CSharpLINQ
{
    class SimpleQuery
    {
        static void Main()
        {
            var students = new[] // Array of objects of an anonymous type
			{
				new { LName="Mishra", FName="Kuldeep", Age=31 },
				new { LName="Sharma", FName="Ramesh", Age=20 },
				new { LName="Sharma", FName="Manoj", Age=21 },
				new { LName="Mishra", FName="Rajesh", Age=45 },
				new { LName="Soni", FName="Suresh", Age=35 },
				new { LName="Goyal", FName="Dinesh", Age=15},
				new { LName="Mishra", FName="Jignesh", Age=31 },
				new { LName="Sharma", FName="Mrigesh", Age=20 },
				new { LName="Verma", FName="Prakash", Age=21 },
				new { LName="Mishra", FName="Aakash", Age=45 },
				new { LName="Soni", FName="Dinkar", Age=35 },
				new { LName="Goyal", FName="Divakar", Age=15},
				new { LName="Goyal", FName="Bhaskar", Age=31 },
				new { LName="Sharma", FName="Tanuj", Age=20 },
				new { LName="Verma", FName="Anuj", Age=21 },
				new { LName="Goyal", FName="Dhanush", Age=45 },
				new { LName="Soni", FName="Mulri", Age=35 },
				new { LName="Goyal", FName="Manohar", Age=15},
				new { LName="Mishra", FName="Sohan", Age=31 },
				new { LName="Sharma", FName="Ram", Age=20 },
				new { LName="Soni", FName="Mohan", Age=21 },
				new { LName="Soni", FName="Rohan", Age=45 },
				new { LName="Soni", FName="Rahul", Age=35 },
				new { LName="Goyal", FName="Rohit", Age=15}
			};

            var query = from student in students group student by student.LName;

            foreach (var student in query)
            {
                Console.WriteLine("\nStudents grouped by Cast: " + student.Key);
                foreach (var q in student)
                    Console.WriteLine("        {0},  Age: {1}", q.FName, q.Age);
            }
        }
    }
}

// Output:
   Students grouped by Cast: Mishra
        Kuldeep,  Age: 31
        Rajesh,  Age: 45
        Jignesh,  Age: 31
        Aakash,  Age: 45
        Sohan,  Age: 31

   Students grouped by Cast: Sharma
        Ramesh,  Age: 20
        Manoj,  Age: 21
        Mrigesh,  Age: 20
        Tanuj,  Age: 20
        Ram,  Age: 20

   Students grouped by Cast: Soni
        Suresh,  Age: 35
        Dinkar,  Age: 35
        Mulri,  Age: 35
        Mohan,  Age: 21
        Rohan,  Age: 45
        Rahul,  Age: 35

   Students grouped by Cast: Goyal
        Dinesh,  Age: 15
        Divakar,  Age: 15
        Bhaskar,  Age: 31
        Dhanush,  Age: 45
        Manohar,  Age: 15
        Rohit,  Age: 15

   Students grouped by Cast: Verma
        Prakash,  Age: 21
        Anuj,  Age: 21

इस Program में हमने निम्नानुसार LINQ Query के माध्‍यम से students नाम के Array Collection के विभिन्न Students Objects को उनके LName यानी Surname के आधार पर Group किया है:

var query = from student in students group student by student.LName;

इसलिए ये Query Fire होने पर समान Surname के Students का पूरा एक Group Return करता है, जिसे फिर से Enumerate किया जा सकता है। इसीलिए हमने हमारे इस Program में निम्नानुसार Nested foreach Looping Construct Define किया है:

            foreach (var student in query)
            {
                Console.WriteLine("\nStudents grouped by Cast: " + student.Key);
                foreach (var q in student)
                    Console.WriteLine("        {0},  Age: {1}", q.FName, q.Age);
            }

जहां अन्दर वाला Loop, बाहर वाले Loop से Return हो रहे “Group of Same Cast Students” के हर Student की Information को Retrieve करने का काम करता है। जबकि हर Group को अलग-अलग Identify करने के लिए निम्न Statement में दर्शा, अनुसार Key का प्रयोग किया जाता है:

        Console.WriteLine(“\nStudents grouped by Cast: ” + student.Key);

यानी यदि सरल शब्दों में कहें तो Outer foreach Loop एक Enumerable Object Return करता है, जिसमें अलग-अलग Cast के Students को एक Key के माध्‍यम से Group-Wise Represent किया जाता है और हर Group स्वयं भी एक Enumerable Object होता है, जिसे Inner Loop द्वारा Process किया जाता है।

join Clause

LINQ का join Clause Exactly SQL के JOIN Clause की तरह ही काम करता है और एक से ज्यादा Data Sources को Combine करते हुए Jointing के आधार पर Result Return करता है।

join Clause का प्रयोग करके हम दो Data Sources को आपस में किसी Specific Condition या Criteria के आधार पर Join करते हैं और फिर इस Joined Collection पर LINQ Query Fire करके Result Generate करते हैं। परिणामस्वरूप Generate होने वाला Result एक नही बल्कि दो या अधिक Joined Data Sources के आधार पर Generate होता है।

यानी सरल शब्दों में कहें तो जब हम join Clause Use करते हैं, तब हम दो Collections को आपस में Join करके एक नया Temporary Collection Create करते हैं और फिर हमारी LINQ Query इस Temporary Collection पर Fire होती है। परिणामस्वरूप जो Result Generate होता है, वह पूरी तरह से दोनों Joined Collections के Data पर आधारित होता है। join Clause को हम निम्नानुसार तरीके से Represent कर सकते हैं:

LINQ Query Expressions - Hindi

LINQ Query Expressions – Hindi

जहां equals Keyword के माध्‍यम से हम दोनों Collections के बीच उस Common Field को आपस में Compare करवा रहे हैं, जिसके आधार पर हमें Joining करनी है। सामान्‍यत: SQL में ये दोनों Fields Primary KeyForeign Keys की तरह Treat होते हैं। इस प्रकार से यदि हम join Clause का प्रयोग करते हुए पूरा LINQ Query Specify करें, तो हमारा Query कुछ निम्नानुसार हो सकता है:

var items = from item1 in collection1 join item2 in collection2
on  item1.Field equals item2.Field
select item;

यदि हम इस join Clause के आधार पर एक Program Crete करते हुए join Clause की Working को Practically समझें, तो हमारा Program कुछ निम्नानुसार हो सकता है:

File Name: groupClause.cs
using System;
using System.Linq;

namespace CSharpLINQ
{
    class SimpleQuery
    {
        static void Main()
        {
            var students = new[] // Array of objects of an anonymous type
			{
				new { ID="101", LName="Mishra", FName="Kuldeep", Age=31, ClassID="101"},
				new { ID="102", LName="Sharma", FName="Ramesh", Age=20, ClassID="101"},
				new { ID="103", LName="Sharma", FName="Manoj", Age=21, ClassID="101"},
				new { ID="104", LName="Mishra", FName="Rajesh", Age=45, ClassID="101"},
				new { ID="105", LName="Soni", FName="Suresh", Age=35, ClassID="102"},
				new { ID="106", LName="Goyal", FName="Dinesh", Age=15, ClassID="102"},
				new { ID="107", LName="Mishra", FName="Jignesh", Age=31, ClassID="103"},
				new { ID="108", LName="Sharma", FName="Mrigesh", Age=20, ClassID="103"},
				new { ID="109", LName="Verma", FName="Prakash", Age=21, ClassID="103"},
				new { ID="110", LName="Mishra", FName="Aakash", Age=45, ClassID="103"},
				new { ID="111", LName="Soni", FName="Dinkar", Age=35, ClassID="102"},
				new { ID="112", LName="Goyal", FName="Divakar", Age=15, ClassID="103"},
				new { ID="113", LName="Goyal", FName="Bhaskar", Age=31, ClassID="103"},
				new { ID="114", LName="Sharma", FName="Tanuj", Age=20, ClassID="104"},
				new { ID="115", LName="Verma", FName="Anuj", Age=21, ClassID="104"},
				new { ID="116", LName="Goyal", FName="Dhanush", Age=45, ClassID="105"},
				new { ID="117", LName="Soni", FName="Mulri", Age=35, ClassID="105"},
				new { ID="118", LName="Goyal", FName="Manohar", Age=15, ClassID="105"},
				new { ID="119", LName="Mishra", FName="Sohan", Age=31, ClassID="105"},
				new { ID="120", LName="Sharma", FName="Ram", Age=20, ClassID="101"},
				new { ID="121", LName="Soni", FName="Mohan", Age=21, ClassID="106"},
				new { ID="122", LName="Soni", FName="Rohan", Age=45, ClassID="106"},
				new { ID="123", LName="Soni", FName="Rahul", Age=35, ClassID="101"},
				new { ID="124", LName="Goyal", FName="Rohit", Age=15, ClassID="106"}
			};

            var Class = new[]
			{
				new { ClassID="101" , Class="I"},
				new { ClassID="102" , Class="II"},
				new { ClassID="103" , Class="III"},
				new { ClassID="104" , Class="IV"},
				new { ClassID="105" , Class="V"},
				new { ClassID="106" , Class="VI"},
			};

            var query = from student in students 
					join cls in Class 
						on student.ClassID equals cls.ClassID 
							where student.ClassID == "103" 
								select student;

            Console.WriteLine("Only Students of Class \"III\":");
            foreach (var q in query)
            {
                Console.WriteLine("    {0},  Age: {1}", q.FName, q.Age);
            }
        }
    }
}

Output:
Only Students of Class "III":
    Jignesh,  Age: 31
    Mrigesh,  Age: 20
    Prakash,  Age: 21
    Aakash,  Age: 45
    Divakar,  Age: 15
    Bhaskar,  Age: 31

इस Program में हमने दो Collections Create किए हैं और दोनों Collections के आधार पर निम्नानुसार join Clause का प्रयोग करते हुए एक LINQ Query Define किया है:

        var query = from student in students 
		join cls in Class 
			on student.ClassID equals cls.ClassID 
				where student.ClassID == "103" 
					select student;

इस LINQ Query को देखकर ही हम समझ सकते हैं कि हम उन सभी Student Objects के सभी Fields को Select कर रहे हैं, जो कि Class “III” में पढते हैं। यानी जब हम join Clause का प्रयोग करते हैं तो उपरोक्त Code के अनुसार हम उन सभी Students की व उनके Class की Information को Retrieve करते हैं, जिनका ClassID “103” है और उसे query नाम के Query Variable में Assign कर देते हैं।

Anonymous Types in C#
Query Method and Expression Tree

C# in Hindiये Article इस वेबसाईट पर Selling हेतु उपलब्‍ध EBook C#.NET in Hindi से लिया गया है। इसलिए यदि ये Article आपके लिए उपयोगी रहा, तो निश्चित रूप से ये पुस्तक भी आपके लिए काफी उपयोगी साबित होगी। 

C#.NET in Hindi | Page:908 | Format: PDF

BUY NOW DOWNLOAD READ ONLINE

Download All Hindi EBooks

सभी हिन्दी EBooks C, C++, Java, C#, ASP.NET, Oracle, Data Structure, VB6, PHP, HTML5, JavaScript, jQuery, WordPress, etc... के DOWNLOAD LINKS प्राप्‍त करें, अपने EMail पर।

Register करके Login करें। इस Popup से छुटकारा पाएें।