linq
मानक क्वेरी ऑपरेटर

टिप्पणियों

कॉनटेनटेशन ऑपरेशंस

एक दूसरे से एक क्रम को जोड़ने के संचालन को संदर्भित करता है।

concat

एक क्रम बनाने के लिए दो क्रमों को समेटता है।

विधि सिंटेक्स

// Concat

var numbers1 = new int[] { 1, 2, 3 };
var numbers2 = new int[] { 4, 5, 6 };

var numbers = numbers1.Concat(numbers2);

// numbers = { 1, 2, 3, 4, 5, 6 }

क्वेरी सिंटैक्स

// Not applicable.

फ़िल्टरिंग संचालन

फ़िल्टरिंग से तात्पर्य केवल उन तत्वों को शामिल करने के लिए निर्धारित परिणाम को सीमित करने के संचालन से है जो एक निर्दिष्ट स्थिति को संतुष्ट करते हैं।

कहाँ पे

उन मानों का चयन करता है जो एक विधेय फ़ंक्शन पर आधारित होते हैं।

विधि सिंटेक्स

// Where

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

var evens = numbers.Where(n => n % 2 == 0);

// evens = { 2, 4, 6, 8 }

क्वेरी सिंटैक्स

// where

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

var odds = from n in numbers
           where n % 2 != 0
           select n;

// odds = { 1, 3, 5, 7 }

OfType

मूल्यों का चयन करता है, एक निर्दिष्ट प्रकार के लिए डाली जाने की उनकी क्षमता पर निर्भर करता है।

विधि सिंटेक्स

// OfType

var numbers = new object[] { 1, "one", 2, "two", 3, "three" };

var strings = numbers.OfType<string>();

// strings = { "one", "two", "three" }

क्वेरी सिंटैक्स

// Not applicable.

ऑपरेशन में शामिल हों

दो डेटा स्रोतों में शामिल होने से एक डेटा स्रोत में ऑब्जेक्ट्स का जुड़ाव होता है जो किसी अन्य डेटा स्रोत में एक सामान्य विशेषता साझा करते हैं।

शामिल हों

प्रमुख चयनकर्ता कार्यों के आधार पर दो अनुक्रमों को जोड़ता है और मूल्यों के जोड़े को निकालता है।

विधि सिंटेक्स

// Join

class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Order
{
    public string Description { get; set; }
    public int CustomerId { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Id = 1, Name = "C1" },
    new Customer { Id = 2, Name = "C2" },
    new Customer { Id = 3, Name = "C3" }
};

var orders = new Order[]
{
    new Order { Description = "O1", CustomerId = 1 },
    new Order { Description = "O2", CustomerId = 1 },
    new Order { Description = "O3", CustomerId = 2 },
    new Order { Description = "O4", CustomerId = 3 },
};

var join = customers.Join(orders, c => c.Id, o => o.CustomerId, (c, o) => c.Name + "-" + o.Description);

// join = { "C1-O1", "C1-O2", "C2-O3", "C3-O4" }

क्वेरी सिंटैक्स

// join … in … on … equals …

var join = from c in customers
           join o in orders
           on c.Id equals o.CustomerId
           select o.Description + "-" + c.Name;

// join = { "O1-C1", "O2-C1", "O3-C2", "O4-C3" }

GroupJoin

मुख्य चयनकर्ता कार्यों के आधार पर दो अनुक्रमों को जोड़ता है और प्रत्येक तत्व के लिए परिणामी मेल खाता है।

विधि सिंटेक्स

// GroupJoin

var groupJoin = customers.GroupJoin(orders,
                                    c => c.Id, 
                                    o => o.CustomerId, 
                                    (c, ors) => c.Name + "-" + string.Join(",", ors.Select(o => o.Description)));

// groupJoin = { "C1-O1,O2", "C2-O3", "C3-O4" }

क्वेरी सिंटैक्स

// join … in … on … equals … into …

var groupJoin = from c in customers
                join o in orders               
                on c.Id equals o.CustomerId
                into customerOrders
                select string.Join(",", customerOrders.Select(o => o.Description)) + "-" + c.Name;

// groupJoin = { "O1,O2-C1", "O3-C2", "O4-C3" }

ज़िप

परिणामों के अनुक्रम का निर्माण करते हुए, दो अनुक्रमों के संबंधित तत्वों को एक निर्दिष्ट फ़ंक्शन लागू करता है।

var numbers = new [] { 1, 2, 3, 4, 5, 6 };
var words = new [] { "one", "two", "three" };

var numbersWithWords =
    numbers
    .Zip(
        words,
        (number, word) => new { number, word });

// Results

//| number | word   |
//| ------ | ------ |
//| 1      |  one   |
//| 2      |  two   |
//| 3      |  three |

प्रोजेक्शन ऑपरेशन

प्रोजेक्शन का तात्पर्य किसी वस्तु को नए रूप में बदलने के संचालन से है।

चुनते हैं

प्रोजेक्ट मान जो एक ट्रांसफ़ॉर्म फ़ंक्शन पर आधारित होते हैं।

विधि सिंटेक्स

// Select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = numbers.Select(n => n.ToString());

// strings = { "1", "2", "3", "4", "5" }

क्वेरी सिंटैक्स

// select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = from n in numbers
              select n.ToString();

// strings = { "1", "2", "3", "4", "5" }

SelectMany

मूल्यों के अनुक्रम अनुक्रम जो एक परिवर्तन समारोह पर आधारित हैं और फिर उन्हें एक क्रम में समतल करते हैं।

विधि सिंटेक्स

// SelectMany

class Customer
{
    public Order[] Orders { get; set; }
}

class Order
{
    public Order(string desc) { Description = desc; }
    public string Description { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Orders = new Order[] { new Order("O1"), new Order("O2") } },
    new Customer { Orders = new Order[] { new Order("O3") } },
    new Customer { Orders = new Order[] { new Order("O4") } },
};

var orders = customers.SelectMany(c => c.Orders);

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

क्वेरी सिंटैक्स

// multiples from

var orders = from c in customers
             from o in c.Orders
             select o;

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

छँटाई संचालन

एक सॉर्टिंग ऑपरेशन एक या अधिक विशेषताओं के आधार पर एक अनुक्रम के तत्वों का आदेश देता है।

द्वारा आदेश

आरोही क्रम में मान बढ़ाता है।

विधि सिंटेक्स

// OrderBy

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

var ordered = numbers.OrderBy(n => n);

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

क्वेरी सिंटैक्स

// orderby

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

var ordered = from n in numbers
              orderby n
              select n;

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

OrderByDescending

अवरोही क्रम में मान बढ़ाता है।

विधि सिंटेक्स

// OrderByDescending

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

var ordered = numbers.OrderByDescending(n => n);

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

क्वेरी सिंटैक्स

// orderby

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

var ordered = from n in numbers
              orderby n descending
              select n;

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

तब तक

आरोही क्रम में एक द्वितीयक प्रकार करता है।

विधि सिंटेक्स

// ThenBy

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w.Length).ThenBy(w => w[0]);

// ordered = { "fox", "the", "brown", "jumps", "quick" }

क्वेरी सिंटैक्स

// orderby …, …

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0]
              select w;

// ordered = { "fox", "the", "brown", "jumps", "quick" }

ThenByDescending

अवरोही क्रम में एक द्वितीयक प्रकार करता है।

विधि सिंटेक्स

// ThenByDescending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w[0]).ThenByDescending(w => w.Length);

// ordered = { "brown", "fox", "jumps", "quick", "the" }

क्वेरी सिंटैक्स

// orderby …, … descending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0] descending
              select w;

// ordered = { "the", "fox", "quick", "jumps", "brown" }

रिवर्स

एक संग्रह में तत्वों के क्रम को उलट देता है।

विधि सिंटेक्स

// Reverse

var numbers = new int[] { 1, 2, 3, 4, 5 };

var reversed = numbers.Reverse();

// reversed = { 5, 4, 3, 2, 1 }

क्वेरी सिंटैक्स

// Not applicable.

रूपांतरण संचालन

रूपांतरण ऑपरेशन इनपुट ऑब्जेक्ट के प्रकार को बदलते हैं।

AsEnumerable

IEnumerable के रूप में टाइप किया गया इनपुट लौटाता है।

विधि सिंटेक्स

// AsEnumerable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

क्वेरी सिंटैक्स

// Not applicable.

AsQueryable

एक IEnumerable को IQueryable में रूपांतरित करता है।

विधि सिंटेक्स

// AsQueryable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

क्वेरी सिंटैक्स

// Not applicable.

कास्ट

संग्रह के तत्वों को एक निर्दिष्ट प्रकार में रखता है।

विधि सिंटेक्स

// Cast

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = numbers.Cast<int>();

// nums: static type is IEnumerable<int>

क्वेरी सिंटैक्स

// Use an explicitly typed range variable.

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = from int n in numbers select n;

// nums: static type is IEnumerable<int>

OfType

एक विशिष्ट प्रकार के लिए डाली जाने की क्षमता के आधार पर फ़िल्टर मान।

विधि सिंटेक्स

// OfType

var objects = new object[] { 1, "one", 2, "two", 3, "three" };

var numbers = objects.OfType<int>();

// nums = { 1, 2, 3 }

क्वेरी सिंटैक्स

// Not applicable.

toArray

एक संग्रह के लिए एक सरणी में कनवर्ट करता है।

विधि सिंटेक्स

// ToArray

var numbers = Enumerable.Range(1, 5);

int[] array = numbers.ToArray();

// array = { 1, 2, 3, 4, 5 }

क्वेरी सिंटैक्स

// Not applicable.

सूची बनाने के लिए

संग्रह को सूची में परिवर्तित करता है।

विधि सिंटेक्स

// ToList

var numbers = Enumerable.Range(1, 5);

List<int> list = numbers.ToList();

// list = { 1, 2, 3, 4, 5 }

क्वेरी सिंटैक्स

// Not applicable.

ToDictionary

एक कुंजी चयनकर्ता फ़ंक्शन के आधार पर एक शब्दकोश में तत्वों को डालता है।

विधि सिंटेक्स

// ToDictionary

var numbers = new int[] { 1, 2, 3 };

var dict = numbers.ToDictionary(n => n.ToString());

// dict = { "1" => 1, "2" => 2, "3" => 3 }

क्वेरी सिंटैक्स

// Not applicable.

एकत्रीकरण संचालन

एकत्रीकरण संचालन मूल्यों के संग्रह से एकल मूल्य की गणना करता है।

कुल

एक संग्रह के मूल्यों पर एक कस्टम एकत्रीकरण ऑपरेशन करता है।

विधि सिंटेक्स

// Aggregate

var numbers = new int[] { 1, 2, 3, 4, 5 };

var product = numbers.Aggregate(1, (acc, n) => acc * n);

// product = 120

क्वेरी सिंटैक्स

// Not applicable.

औसत

मूल्यों के संग्रह के औसत मूल्य की गणना करता है।

विधि सिंटेक्स

// Average

var numbers = new int[] { 1, 2, 3, 4, 5 };

var average = numbers.Average();

// average = 3

क्वेरी सिंटैक्स

// Not applicable.

गिनती

एक संग्रह में तत्वों को गिना जाता है, वैकल्पिक रूप से केवल उन तत्वों को जो एक समर्पित कार्य को पूरा करते हैं।

विधि सिंटेक्स

// Count

var numbers = new int[] { 1, 2, 3, 4, 5 };

int count = numbers.Count(n => n % 2 == 0);

// count = 2

क्वेरी सिंटैक्स

// Not applicable.

LongCount

तत्वों को एक बड़े संग्रह में गिना जाता है, वैकल्पिक रूप से केवल उन तत्वों को जो एक समर्पित कार्य को पूरा करते हैं।

विधि सिंटेक्स

// LongCount

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

long count = numbers.LongCount();

// count = 10

क्वेरी सिंटैक्स

// Not applicable.

मैक्स

एक संग्रह में अधिकतम मूल्य निर्धारित करता है। यदि संग्रह खाली है तो अपवाद छोड़ देता है।

विधि सिंटेक्स

// Max

var numbers = new int[] { 1, 2, 3, 4, 5 };

var max = numbers.Max();

// max = 5

क्वेरी सिंटैक्स

// Not applicable.

मिन

एक संग्रह में न्यूनतम मूल्य निर्धारित करता है। यदि संग्रह खाली है तो अपवाद छोड़ देता है।

विधि सिंटेक्स

// Min

var numbers = new int[] { 1, 2, 3, 4, 5 };

var min = numbers.Min();

// min = 1

क्वेरी सिंटैक्स

// Not applicable.

Min- / MaxOrDefault

अन्य LinQ एक्सटेंशन के विपरीत Min() और Max() अपवाद के बिना अधिभार नहीं है। IEnumerable को Any() Min() या Max() कॉल करने से पहले IEnumerable चाहिए

// Max

var numbers = new int[] { };

var max = numbers.Any() ? numbers.Max() : 0;

// max = 0

योग

एक संग्रह में मूल्यों के योग की गणना करता है।

विधि सिंटेक्स

// Sum

var numbers = new int[] { 1, 2, 3, 4, 5 };

var sum = numbers.Sum();

// sum = 15

क्वेरी सिंटैक्स

// Not applicable.

मात्रात्मक संचालन

क्वांटिफायर ऑपरेशन एक बूलियन मान लौटाते हैं जो इंगित करता है कि एक क्रम में कुछ या सभी तत्व एक शर्त को पूरा करते हैं।

सब

निर्धारित करता है कि एक क्रम में सभी तत्व एक शर्त को पूरा करते हैं या नहीं।

विधि सिंटेक्स

// All

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool areLessThan10 = numbers.All(n => n < 10);

// areLessThan10 = true

क्वेरी सिंटैक्स

// Not applicable.

कोई भी

निर्धारित करता है कि क्या किसी अनुक्रम में कोई तत्व किसी स्थिति को संतुष्ट करता है।

विधि सिंटेक्स

// Any

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool anyOneIsEven = numbers.Any(n => n % 2 == 0);

// anyOneIsEven = true

क्वेरी सिंटैक्स

// Not applicable.

शामिल

निर्धारित करता है कि किसी अनुक्रम में एक निर्दिष्ट तत्व है या नहीं।

विधि सिंटेक्स

// Contains

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool appears = numbers.Contains(10);

// appears = false

क्वेरी सिंटैक्स

// Not applicable.

समूह संचालन

समूहीकरण से तात्पर्य समूहों में डेटा डालने के संचालन से है ताकि प्रत्येक समूह के तत्व एक समान विशेषता साझा करें।

समूह द्वारा

एक सामान्य विशेषता साझा करने वाले समूह तत्व।

विधि सिंटेक्स

// GroupBy

class Order
{
    public string Customer { get; set; }
    public string Description { get; set; }
}
...

var orders = new Order[] 
{
    new Order { Customer = "C1", Description = "O1" },
    new Order { Customer = "C2", Description = "O2" },
    new Order { Customer = "C3", Description = "O3" },
    new Order { Customer = "C1", Description = "O4" },
    new Order { Customer = "C1", Description = "O5" },
    new Order { Customer = "C3", Description = "O6" },
};

var groups = orders.GroupBy(o => o.Customer);

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

क्वेरी सिंटैक्स

// group … by

var groups = from o in orders
             group o by o.Customer;

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

देखने के लिए

एक प्रमुख चयनकर्ता फ़ंक्शन के आधार पर एक से कई शब्दकोश में तत्वों को सम्मिलित करता है।

विधि सिंटेक्स

// ToLookUp

var ordersByCustomer = orders.ToLookup(o => o.Customer);

// ordersByCustomer = ILookUp<string, Order>
// {
//     "C1" => { Order("01"), Order("04"), Order("05") },
//     "C2" => { Order("02") },
//     "C3" => { Order("03"), Order("06") }
// }

क्वेरी सिंटैक्स

// Not applicable.

विभाजन संचालन

विभाजन एक इनपुट अनुक्रम को दो खंडों में विभाजित करने के संचालन को संदर्भित करता है, तत्वों को फिर से व्यवस्थित किए बिना, और फिर किसी एक खंड को वापस करना।

छोड़ें

एक अनुक्रम में निर्दिष्ट स्थिति तक के तत्व को छोड़ देता है।

विधि सिंटेक्स

// Skip

var numbers = new int[] { 1, 2, 3, 4, 5 };

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

क्वेरी सिंटैक्स

// Not applicable.

SkipWhile

जब तक कोई तत्व स्थिति को संतुष्ट नहीं करता है, तब तक एक समर्पित कार्य पर आधारित स्काइप तत्व।

विधि सिंटेक्स

// Skip

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var skipLeadingOdds = numbers.SkipWhile(n => n % 2 != 0);

// skipLeadingOdds = { 2, 1, 3, 5 }

क्वेरी सिंटैक्स

// Not applicable.

लेना

एक अनुक्रम में निर्दिष्ट स्थिति तक तत्वों को ले जाता है।

विधि सिंटेक्स

// Take

var numbers = new int[] { 1, 2, 3, 4, 5 };

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

क्वेरी सिंटैक्स

// Not applicable.

TakeWhile

एक विधेय फ़ंक्शन के आधार पर तत्वों को तब तक ले जाता है जब तक कोई तत्व स्थिति को संतुष्ट नहीं करता है।

विधि सिंटेक्स

// TakeWhile

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var takeLeadingOdds = numbers.TakeWhile(n => n % 2 != 0);

// takeLeadingOdds = { 1, 3, 5 }

क्वेरी सिंटैक्स

// Not applicable.

जनरेशन ऑपरेशन

सृजन से तात्पर्य मूल्यों के एक नए क्रम को बनाने से है।

DefaultIfEmpty

एक डिफ़ॉल्ट मूल्यवान सिंगलटन संग्रह के साथ एक खाली संग्रह की जगह।

विधि सिंटेक्स

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

क्वेरी सिंटैक्स

// Not applicable.

खाली

एक खाली संग्रह लौटाता है।

विधि सिंटेक्स

// Empty

var empty = Enumerable.Empty<string>();

// empty = IEnumerable<string> { }

क्वेरी सिंटैक्स

// Not applicable.

रेंज

एक संग्रह बनाता है जिसमें संख्याओं का एक क्रम होता है।

विधि सिंटेक्स

// Range

var range = Enumerable.Range(1, 5);

// range = { 1, 2, 3, 4, 5 }

क्वेरी सिंटैक्स

// Not applicable.

दोहराना

एक संग्रह बनाता है जिसमें एक दोहराया मूल्य होता है।

विधि सिंटेक्स

// Repeat

var repeats = Enumerable.Repeat("s", 3);

// repeats = { "s", "s", "s" }

क्वेरी सिंटैक्स

// Not applicable.

संचालन सेट करें

सेट ऑपरेशंस क्वेरी ऑपरेशंस को संदर्भित करते हैं जो एक परिणाम सेट का उत्पादन करते हैं जो समान या अलग संग्रह (या सेट) के भीतर समकक्ष तत्वों की उपस्थिति या अनुपस्थिति पर आधारित होता है।

अलग

एक संग्रह से डुप्लिकेट मान निकालता है।

विधि सिंटेक्स

// Distinct

var numbers = new int[] { 1, 2, 3, 1, 2, 3 };

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

क्वेरी सिंटैक्स

// Not applicable.

के सिवाय

सेट अंतर लौटाता है, जिसका अर्थ है एक संग्रह के तत्व जो दूसरे संग्रह में दिखाई नहीं देते हैं।

विधि सिंटेक्स

// Except

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var except = numbers1.Except(numbers2);

// except = { 1, 2, 3 }

क्वेरी सिंटैक्स

// Not applicable.

इंटरसेक्ट

सेट प्रतिच्छेदन लौटाता है, जिसका अर्थ है कि तत्व जो प्रत्येक दो संग्रह में दिखाई देते हैं।

विधि सिंटेक्स

// Intersect

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var intersect = numbers1.Intersect(numbers2);

// intersect = { 4, 5 }

क्वेरी सिंटैक्स

// Not applicable.

संघ

सेट संघ लौटाता है, जिसका अर्थ है अद्वितीय तत्व जो दो संग्रह में से किसी एक में दिखाई देते हैं।

विधि सिंटेक्स

// Union

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var union = numbers1.Union(numbers2);

// union = { 1, 2, 3, 4, 5, 6, 7, 8 }

क्वेरी सिंटैक्स

// Not applicable.

समानता संचालन

दो अनुक्रम जिनके संबंधित तत्व समान हैं और जिनमें समान तत्व हैं समान माना जाता है।

SequenceEqual

यह निर्धारित करता है कि जोड़ी-वार तरीके से तत्वों की तुलना करके दो अनुक्रम समान हैं या नहीं।

विधि सिंटेक्स

// SequenceEqual

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 1, 2, 3, 4, 5 };

var equals = numbers1.SequenceEqual(numbers2);

// equals = true

क्वेरी सिंटैक्स

// Not Applicable.

तत्व संचालन

तत्व ऑपरेशन एक अनुक्रम से एक एकल, विशिष्ट तत्व लौटाते हैं।

ElementAt

एक संग्रह में एक निर्दिष्ट सूचकांक पर तत्व देता है।

विधि सिंटेक्स

// ElementAt

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAt(2);

// str = "two"

क्वेरी सिंटैक्स

// Not Applicable.

ElementAtOrDefault

किसी संग्रह में निर्दिष्ट सूचकांक पर तत्व लौटाता है या यदि सूचकांक सीमा से बाहर है, तो एक डिफ़ॉल्ट मान।

विधि सिंटेक्स

// ElementAtOrDefault

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAtOrDefault(10);

// str = null

क्वेरी सिंटैक्स

// Not Applicable.

प्रथम

संग्रह का पहला तत्व, या पहला तत्व जो किसी शर्त को पूरा करता है।

विधि सिंटेक्स

// First

var numbers = new int[] { 1, 2, 3, 4, 5 };

var first = strings.First();

// first = 1

क्वेरी सिंटैक्स

// Not Applicable.

FirstOrDefault

संग्रह का पहला तत्व, या पहला तत्व जो किसी शर्त को पूरा करता है। यदि कोई ऐसा तत्व मौजूद है, तो डिफ़ॉल्ट मान लौटाता है।

विधि सिंटेक्स

// FirstOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var firstGreaterThanTen = strings.FirstOrDefault(n => n > 10);

// firstGreaterThanTen = 0

क्वेरी सिंटैक्स

// Not Applicable.

अंतिम

किसी संग्रह के अंतिम तत्व, या किसी शर्त को पूरा करने वाला अंतिम तत्व देता है।

विधि सिंटेक्स

// Last

var numbers = new int[] { 1, 2, 3, 4, 5 };

var last = strings.Last();

// last = 5

क्वेरी सिंटैक्स

// Not Applicable.

LastOrDefault

किसी संग्रह के अंतिम तत्व, या किसी शर्त को पूरा करने वाला अंतिम तत्व देता है। यदि कोई ऐसा तत्व मौजूद नहीं है, तो डिफ़ॉल्ट मान लौटाता है।

विधि सिंटेक्स

// LastOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var lastGreaterThanTen = strings.LastOrDefault(n => n > 10);

// lastGreaterThanTen = 0

क्वेरी सिंटैक्स

// Not Applicable.

एक

एक संग्रह का एकमात्र तत्व, या एकमात्र तत्व जो किसी स्थिति को संतुष्ट करता है, लौटाता है।

विधि सिंटेक्स

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

क्वेरी सिंटैक्स

// Not Applicable.

SingleOrDefault

एक संग्रह का एकमात्र तत्व, या एकमात्र तत्व जो किसी स्थिति को संतुष्ट करता है, लौटाता है। यदि कोई ऐसा तत्व मौजूद है या संग्रह में ठीक एक तत्व नहीं है, तो एक डिफ़ॉल्ट मान लौटाता है।

विधि सिंटेक्स

// SingleOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var singleGreaterThanFour = strings.SingleOrDefault(n => n > 4);

// singleGreaterThanFour = 5

क्वेरी सिंटैक्स

// Not Applicable.