Arrêter une boucle à l'intérieur d'une méthode en C #

Question

Yat-il un moyen d'arrêter une boucle en cours d'exécution dans une autre méthode ou insérer une instruction break dynamique en C #?

Merci

Edit: Je veux être en mesure de façon dynamique la méthode d'interception et d'insérer une pause pour arrêter la boucle quand un événement se déclenche dans un autre function.I avoir plusieurs instances de la classe et je veux arrêter la boucle dans chaque cas chaque fois nécessaires et de gérer toutes les instances. Pensez à plusieurs instances d'être dans une liste générique

Exemple:

List<myclass> objlist=new List<myclass>();

foreach(myclass obj in objlist)
{
obj.loopingfunction().BreakLoop //or something like this (assuming that the loopingfunction is already called)
}

J'ai besoin parce que je veux rompre la boucle une fois l'utilisateur stocke une énorme quantité de data.When l'utilisateur importe les données, je reçois un événement déclenché. Mais je ne peux pas garder le contrôle de la base de données de plusieurs instances car elle plisse SQLServer.

Ceci est une application ASP.Net.

Answer 1

Si la chose est en cours d'exécution dans un seul thread, il ne serait pas de sens. Si la boucle est en cours d'exécution, alors rien d'autre en cours d'exécution en même temps. Si vous utilisez une boucle sur un autre thread et la méthode de contrôle sur un autre thread, vous pouvez interrompre le fil de boucle complètement ou vérifier un drapeau à l'intérieur de la boucle de décider si oui ou non vous devez casser et mettre le drapeau de façon appropriée dans la méthode de contrôle .

Mise à jour: faire cette fonction retourne une valeur booléenne indiquant si vous devez casser et de l'utiliser dans une instruction « if »:

if (myFunctionShouldBreakLoop()) break;

Answer 2

Une autre option serait de soulever CancelEventArgs à chaque itération de la boucle. Probablement pas le plus efficace, mais néanmoins une autre option:

    private void SomeMethod()
    {
        for (int i = 0; i <= 100000; i++)
        {
            Console.WriteLine(i);
            if (LoopIncrement != null)
            {
                CancelEventArgs args = new CancelEventArgs();
                LoopIncrement(null, args);
                if (args.Cancel)
                {
                    break;
                }
            }
        }

Et ailleurs:

myObj.LoopIncrement += MyHandler;

private void MyHandler(object sender, CancelEventArgs e)
{
   if(someCondition)
   {
      e.Cancel = true;
   }
}

De cette façon, vous pouvez contrôler un peu la boucle de l'extérieur ....

Answer 3

Avoir la condition dans une propriété verrouillée.

private Boolean BreakCondition
{
    get { lock(_LockObject) { return _BreakCondition; }  }
    set { lock(_LockObject) { _BreakCondition = value; }  }
}
private Boolean _BreakCondition = false;
private Object _LockObject = new Object();


if (this.BreakCondition)
{
    break;
}

Answer 4

Comment l'utilisation itérateurs, et la magie de rendement pour résoudre le problème.

Voici un article sur les listes infinies qui pourraient être utiles

http: // www .codethinked.com / post / 2009/02/04 / infinie Listes-Avec-C-Yield.aspx

 class Program
    {
        static void Main(string[] args)
        {
            Predicate<int> when = i => i > 100 && Console.ReadKey().KeyChar.ToString() == "0";

            foreach(var i in Numbers().BreakOn(when))
            {
                Console.WriteLine(i);
            }

            Console.ReadLine();
        }

        private static IEnumerable<int> Numbers()
        {
            var i = 0;
            while(true)
            {
                yield return i++;
            }
        }


    }

    public static class Util
    {
        public static IEnumerable<int> BreakOn(this IEnumerable<int> sequence, Predicate<int> when)
        {
            foreach(int i in sequence)
            {
                if(when(i))
                {
                    yield break;
                }
                yield return i;
            }
        }
}

Answer 5

Je pense que vous pouvez utiliser l'indicateur

bool stop = false;

for(int i=0;i<num;i++) 
{
 if(stop) break;
}

Answer 6

La réponse courte est: non. Si vous ne contrôlez pas le code, alors vous ne pouvez pas faire la boucle de mettre fin.

Si vous ne contrôlez le code, vous pouvez construire dans une sorte de coopération, mais il semble en désordre. Peut-être que vous pouvez expliquer pourquoi?