Interrompere un ciclo all'interno di un metodo in C #

Question

C'è un modo per fermare un ciclo in esecuzione all'interno di un altro metodo o inserire un'istruzione break dinamico in C #?

Grazie

Edit: Voglio essere in grado di intercettare in modo dinamico il metodo e inserire una pausa per interrompere il ciclo quando un evento viene attivato in un altro function.I avere diverse istanze della classe e voglio fermare il ciclo in ogni caso ogni volta richieste e gestire tutte le istanze. Considerare più istanze di essere in un elenco generico

Esempio:

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)
}

Ho bisogno di questo perché voglio rompere il ciclo una volta che l'utente memorizza una certa quantità enorme di data.When l'utente importa i dati, ho un evento generato. Ma non posso continuare a controllare il database da più istanze dal momento che le viti fino SQLServer.

Questo è in un'applicazione ASP.Net.

Answer 1

Se il tutto è in esecuzione in un singolo thread, non avrebbe alcun senso. Se il ciclo è in esecuzione, quindi niente altro è in esecuzione allo stesso tempo. Se si sta eseguendo un loop su un altro thread e il metodo di controllo su un altro thread, è possibile interrompere il filo ciclo completamente o controllare un flag all'interno del ciclo di decidere se o non si dovrebbe rompere e impostare il flag in modo appropriato nel metodo di controllo .

Aggiornamento: fa che la funzione restituisce un valore booleano che indica se è necessario rompere e utilizzarlo in un comunicato "if":

if (myFunctionShouldBreakLoop()) break;

Answer 2

Un'altra opzione sarebbe quella di sollevare CancelEventArgs durante ogni iterazione del ciclo. Probabilmente non è la più efficiente, ma un'altra opzione comunque:

    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;
                }
            }
        }

E poi altrove:

myObj.LoopIncrement += MyHandler;

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

In questo modo è possibile in qualche modo controllare il ciclo di fuori ....

Answer 3

avere la condizione in una proprietà chiusa a chiave.

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

Come sull'utilizzo iteratori, e la magia resa per risolvere il problema.

Ecco un articolo su liste infinite che potrebbero essere utili

http: // www .codethinked.com / post / 2009/02/04 / Infinite-liste-Con-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

Penso che si possa utilizzare bandiera

bool stop = false;

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

Answer 6

La risposta è: no. Se non si controlla il codice, allora non si può causare il loop per terminare.

Se fai controllare il codice, si potrebbe costruire in una sorta di cooperazione, ma suona disordinato. Forse si può approfondire perché?