C# Language
लूपिंग

लूपिंग स्टाइल

जबकि

सबसे तुच्छ लूप प्रकार। केवल दोष यह है कि आप लूप में कहां हैं, यह जानने के लिए कोई आंतरिक सुराग नहीं है।

/// loop while the condition satisfies
while(condition)
{
    /// do something
}

कर

while इसी तरह, लेकिन स्थिति का मूल्यांकन शुरुआत के बजाय लूप के अंत में किया जाता है। यह कम से कम एक बार छोरों को निष्पादित करने का परिणाम है।

do
{
    /// do something
} while(condition) /// loop while the condition satisfies

के लिये

एक और तुच्छ पाश शैली। एक इंडेक्स को लूप करते समय ( i ) बढ़ जाता है और आप इसका उपयोग कर सकते हैं। आमतौर पर इसका उपयोग सरणियों को संभालने के लिए किया जाता है।

for ( int i = 0; i < array.Count; i++ )
{
    var currentItem = array[i];
    /// do something with "currentItem"
}

प्रत्येक के लिए

IEnumarable वस्तुओं के माध्यम से पाशन का आधुनिक तरीका। अच्छी बात यह है कि आपको सूची के आइटम या आइटम की सूची के बारे में सोचने की ज़रूरत नहीं है।

foreach ( var item in someList )
{
    /// do something with "item"
}

Foreach विधि

जबकि अन्य शैलियों का उपयोग संग्रह में तत्वों को चुनने या अपडेट करने के लिए किया जाता है, इस शैली का उपयोग आमतौर पर संग्रह में सभी तत्वों के लिए एक विधि को सीधे कॉल करने के लिए किया जाता है।

list.ForEach(item => item.DoSomething());

// or
list.ForEach(item => DoSomething(item));

// or using a method group
list.ForEach(Console.WriteLine);

// using an array
Array.ForEach(myArray, Console.WriteLine);

यह ध्यान रखना महत्वपूर्ण है कि यह विधि केवल List<T> उदाहरणों पर उपलब्ध है और Array पर एक स्थिर विधि के रूप में - यह Linq का हिस्सा नहीं है ।

लाइनक समानांतर फ़ॉरच

लिनक फ़ॉरच की तरह, सिवाय इसके कि एक समानांतर तरीके से काम करता है। मतलब कि संग्रह की सभी वस्तुएँ दी गई क्रिया को एक साथ, एक साथ चलाएंगी।

collection.AsParallel().ForAll(item => item.DoSomething());

/// or
collection.AsParallel().ForAll(item => DoSomething(item));

टूटना

कभी-कभी लूप की स्थिति लूप के बीच में जाँच की जानी चाहिए। पूर्व निश्चित रूप से बाद की तुलना में अधिक सुरुचिपूर्ण है:

for (;;)
{
    // precondition code that can change the value of should_end_loop expression

    if (should_end_loop)
        break;

    // do something
}

वैकल्पिक:

bool endLoop = false;
for (; !endLoop;)
{
    // precondition code that can set endLoop flag

    if (!endLoop)
    {
        // do something
    }
}

नोट: नेस्टेड छोरों और / या switch एक साधारण break से अधिक का उपयोग करना चाहिए।

फोरच लूप

foreach IEnumerable लागू करने वाले वर्ग के किसी भी ऑब्जेक्ट पर पुनरावृत्ति करेगा (ध्यान दें कि IEnumerable<T> विरासत में मिला है)। इस तरह की वस्तुओं में कुछ बिल्ट-इन शामिल होते हैं, लेकिन Dictionary<TKey, TSource> सीमा नहीं होती है: List<T> , T[] (किसी भी प्रकार की सरणियाँ), Dictionary<TKey, TSource> , साथ ही IQueryable और ICollection , आदि जैसे IQueryable ।

वाक्य - विन्यास

foreach(ItemType itemVariable in enumerableObject)
    statement;

टिप्पणियों

1. प्रकार ItemType मदों की सटीक प्रकार से मेल की जरूरत नहीं है, यह सिर्फ आइटम के प्रकार से आबंटित करने की जरूरत है
2. ItemType बजाय, वैकल्पिक रूप से var का उपयोग किया जा सकता है, जो IEnumerable कार्यान्वयन के सामान्य तर्क का निरीक्षण करके ItemType से आइटम प्रकार का अनुमान ItemType
3. बयान एक ब्लॉक, एक एकल बयान या यहां तक कि एक खाली बयान ( ; ) हो सकता है
4. यदि enumerableObject IEnumerable लागू नहीं कर रहा है, तो कोड संकलन नहीं करेगा
5. प्रत्येक यात्रा के दौरान वर्तमान आइटम को डाला जाता है ItemType (यह निर्दिष्ट नहीं है, भले ही लेकिन के माध्यम से संकलक-inferred var ) और यदि आइटम ढाला नहीं जा सकता एक InvalidCastException फेंक दिया जाएगा।

इस उदाहरण पर विचार करें:

var list = new List<string>();
list.Add("Ion");
list.Add("Andrei");
foreach(var name in list)
{
    Console.WriteLine("Hello " + name);
}

के बराबर है:

var list = new List<string>();
list.Add("Ion");
list.Add("Andrei");
IEnumerator enumerator;
try
{
    enumerator = list.GetEnumerator();
    while(enumerator.MoveNext())
    {
        string name = (string)enumerator.Current;
        Console.WriteLine("Hello " + name);
    }
}
finally
{
    if (enumerator != null)
        enumerator.Dispose();
}

घुमाव के दौरान

int n = 0;
while (n < 5) 
{
    Console.WriteLine(n);
    n++;
}

आउटपुट:

0
1
2
3
4

IEnumerators थोड़ी देर लूप के साथ पुनरावृत्त हो सकते हैं:

// Call a custom method that takes a count, and returns an IEnumerator for a list
// of strings with the names of theh largest city metro areas.
IEnumerator<string> largestMetroAreas = GetLargestMetroAreas(4);

while (largestMetroAreas.MoveNext())
{
    Console.WriteLine(largestMetroAreas.Current);
}

नमूना उत्पादन:

टोक्यो / योकोहामा
न्यूयॉर्क मेट्रो
साओ पाउलो
सियोल / Incheon

पाश के लिए

A लूप एक निश्चित समय के लिए चीजों को करने के लिए महान है। यह थोड़ी देर के लूप की तरह है, लेकिन वेतन वृद्धि शर्त के साथ शामिल है।

ए फॉर लूप इस तरह स्थापित किया गया है:

for (Initialization; Condition; Increment)
{
    // Code
}

इनिशियलाइज़ेशन - एक नया स्थानीय वैरिएबल बनाता है जिसे केवल लूप में इस्तेमाल किया जा सकता है।
स्थिति - लूप केवल तभी चलता है जब स्थिति सही होती है।
वृद्धि - लूप के चलने पर चर हर बार कैसे बदलता है।

एक उदाहरण:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

आउटपुट:

0
1
2
3
4

आप फ़ॉर लूप में रिक्त स्थान भी छोड़ सकते हैं, लेकिन इसके कार्य करने के लिए आपके पास सभी अर्धविराम होना चाहिए।

int input = Console.ReadLine();    

for ( ; input < 10; input + 2)
{
    Console.WriteLine(input);
}

3 के लिए आउटपुट:

3
5
7
9
1 1

क्या - जबकि लूप

यह while लूप के समान है, सिवाय इसके कि यह लूप बॉडी के अंत में स्थिति का परीक्षण करता है। दो - लूप एक बार लूप को निष्पादित करता है, भले ही यह शर्त सही हो या न हो।

int[] numbers = new int[] { 6, 7, 8, 10 };
    
// Sum values from the array until we get a total that's greater than 10,
// or until we run out of values.
int sum = 0;
int i = 0;
do
{
    sum += numbers[i];
    i++;
} while (sum <= 10 && i < numbers.Length);
    
System.Console.WriteLine(sum); // 13

स्थिर फंदा

// Print the multiplication table up to 5s
for (int i = 1; i <= 5; i++)
{
    for (int j = 1; j <= 5; j++)
    {
        int product = i * j;
        Console.WriteLine("{0} times {1} is {2}", i, j, product);
    }
}

जारी रखें

break अलावा, वहाँ भी कीवर्ड continue । पूरी तरह से लूप को तोड़ने के बजाय, यह केवल वर्तमान पुनरावृत्ति को छोड़ देगा। यह उपयोगी हो सकता है यदि आप नहीं चाहते कि कोई कोड निष्पादित किया जाए यदि कोई विशेष मान सेट किया गया है।

यहाँ एक सरल उदाहरण है:

for (int i = 1; i <= 10; i++)
{
    if (i < 9)
        continue;

    Console.WriteLine(i);
}

में परिणाम होगा:

9
10

नोट: Continue लिए या करते समय अक्सर सबसे उपयोगी होता है। फ़ॉर-लूप, अच्छी तरह से परिभाषित निकास स्थितियों के साथ, उतना लाभ नहीं हो सकता है।