मैं एक अज्ञात प्रतिनिधि का उपयोग करते समय सूची <string> के लिए कैसे बाहर निकल सकता हूं?

Question

एक सामान्य पाश में आप ब्रेक का उपयोग करके लूप से बाहर निकल सकते हैं। क्या एक अज्ञात प्रतिनिधि का उपयोग करके किया जा सकता है?

उदाहरण इनपुटस्ट्रिंग और परिणाम दोनों प्रतिनिधि के बाहर घोषित किए गए हैं।

blackList.ForEach(new Action<string>(
    delegate(string item) 
    { 
     if(inputString.Contains(item)==true) 
     { 
      result = true; 
      // I want to break here 
     } 
    } 
)); 

संपादित करें: उत्तर के लिए धन्यवाद, मैं वास्तव में मिनट जॉन पर अपनी पुस्तक पढ़ रहा हूँ :) बस रिकार्ड के लिए मैं इस मुद्दे को मारा और एक सामान्य foreach पाश में वापस स्विच, लेकिन मैं करने के लिए इस प्रश्न पोस्ट देखें कि मुझे कुछ याद आया या नहीं।

Answer 1

जैसा कि अन्य ने पोस्ट किया है, आप ForEach में लूप से बाहर नहीं निकल सकते हैं।

क्या आप LINQ का उपयोग करने में सक्षम हैं? यदि ऐसा है, तो आप आसानी से TakeWhile और एक कस्टम ForEach एक्सटेंशन विधि को जोड़ सकते हैं (जो कि लगभग हर प्रोजेक्ट में इन दिनों लगता है)।

अपने उदाहरण में, हालांकि, List<T>.FindIndex सबसे अच्छा विकल्प हो सकता है - लेकिन अगर आप वास्तव में कर रही नहीं कर रहे हैं, तो आप वास्तव में क्या करना चाहते हैं उसका एक उदाहरण पोस्ट करें।

Answer 2

लूप को "बाहर निकलने" का एकमात्र तरीका अपवाद फेंकना है। ForEach विधि से बाहर निकलने का कोई "ब्रेक" स्टाइल तरीका नहीं है जैसे आप सामान्य फोरैच लूप करेंगे।

Answer 3

मुझे नहीं लगता कि फॉरएच विधि का उपयोग करते समय ऐसा करने का एक शानदार तरीका है। एक हैकी समाधान अपवाद फेंकना है।

आपको पुरानी शैली के फ़ोरैच करने से क्या रोक रहा है?

foreach (string item in blackList) 
{ 
    if (!inputString.Contains(item)) continue; 

    result = true; 
    break; 
} 

Answer 4

यदि आप एक पाश चाहते हैं, तो एक लूप का उपयोग करें।

Action कोई वापसी मूल्य की अनुमति नहीं देता है, इसलिए कोई तरीका नहीं है कि फॉरएच फ़ंक्शन संभवतः यह जान सके कि आप ब्रेक करना चाहते हैं, अपवाद फेंकने से कम। यहां एक अपवाद का उपयोग करना अधिक है।

Answer 5

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

Answer 6

कोई लूप नहीं है जिसकी पहुंच है, जिससे इसे तोड़ना है। और (अज्ञात) प्रतिनिधि को प्रत्येक कॉल एक नया फ़ंक्शन कॉल है, इसलिए स्थानीय चर मदद नहीं करेंगे। लेकिन चूंकि सी # आप एक बंद कर देता है, तो आप एक ध्वज सेट और फिर कर सकते हैं आगे कॉल में कुछ नहीं कर: (। ऐसा तब बंद करने के लिए सही संदर्भ अर्थ विज्ञान उत्पन्न होता है की जाँच करने के परीक्षण किया जाना चाहिए)

bool stop = false; 
myList.ForEach((a) => { 
    if (stop) { 
    return; 
    } else if (a.SomeCondition()) { 
    stop = true; 
    } 
}); 

static class MyExtensions { 
    static void ForEachStoppable<T>(this IEnumerable<T> input, Func<T, bool> action) { 
    foreach (T t in input) { 
     if (!action(t)) { 
     break; 
     } 
    } 
    } 
} 

Answer 7

आप LINQ आप के लिए उपलब्ध है: एक और अधिक उन्नत दृष्टिकोण अपना स्वयं का एक्सटेंशन विधि है कि पाश को रोकने के लिए प्रतिनिधि झूठी लौटने की अनुमति बनाने के लिए हो सकता है?आपका तर्क किसी भी के समान लगता है:

bool any = blackList.Any(s=>inputString.Contains(s)); 

जो एक ही है के रूप में:

bool any = blackList.Any(inputString.Contains); 

आप LINQ की जरूरत नहीं है, तो यह अभी भी एक ही है के रूप में:

bool any = blackList.Find(inputString.Contains) != null; 

यदि आप अतिरिक्त तर्क चलाने के लिए चाहते हैं, तो ऐसी चीजें हैं जो आप कर सकते हैं (LINQ के साथ) TakeWhile आदि

Answer 8

class Program 
{ 
    static void Main(string[] args) 
    { 
     List<string> blackList = new List<string>(new[] { "jaime", "jhon", "febres", "velez" }); 
     string inputString = "febres"; 
     bool result = false; 
     blackList.ForEach((item) => 
           { 
            Console.WriteLine("Executing"); 
            if (inputString.Contains(item)) 
            { 
             result = true; 
             Console.WriteLine("Founded!"); 
            } 
           }, 
         () => result); 
     Console.WriteLine(result); 
     Console.ReadLine(); 
    } 


} 
public static class MyExtensions 
{ 
    public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action, Func<bool> breakOn) 
    { 
     foreach (var item in enumerable) 
     { 
      action(item); 
      if (breakOn()) 
      { 
       break; 
      } 
     } 
    } 
} 

Answer 9

bool @break = false; 

blackList.ForEach(item => 
{ 
    if(!@break && inputString.Contains(item)) 
    { @break = true; 
     result = true; 
    } 

    if (@break) return; 
    /* ... */ 
}); 

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

Answer 10

क्या आप के लिए यह काम:

bool result = null != blackList.Find(item => inputString.Contains(item))); 

Answer 11

आप इस कोड की तरह अपवाद इस्तेमाल कर सकते हैं अगर तुम सच में एक सूची में एक पाश foreach मौजूद हैं:

public class ExitMyForEachListException : Exception 
{ 
    public ExitMyForEachListException(string message) 
     : base(message) 
    { 
    } 
} 
class Program 
{ 
    static void Main(string[] args) 
    { 
     List<string> str = new List<string>() { "Name1", "name2", "name3", "name4", "name5", "name6", "name7" }; 
     try 
     { 
      str.ForEach(z => 
      { 
       if (z.EndsWith("6")) 
        throw new ExitMyForEachListException("I get Out because I found name number 6!"); 
       System.Console.WriteLine(z); 
      }); 
     } 
     catch (ExitMyForEachListException ex) 
     { 
      System.Console.WriteLine(ex.Message); 
     } 

     System.Console.Read(); 
    } 
} 

आशा पाने के लिए इस मदद अन्य दृष्टिकोण।