Foreach-Schleife in C # neu starten?

Wie kann ich starten Sie eine foreach - Schleife in C#??

Beispiel:

Action a;
foreach(Constrain c in Constrains)
{
   if(!c.Allows(a))
   {
      a.Change();
      restart;
   }
}

restart hier ist wie continue oder break aber es startet den foreach-von Anfang an
Es ist wie das setzen der Zähler von einer for Schleife wieder auf 0..

Ist das möglich in C#?

Edit:ich möchte Ihnen beiden danken, dass Mehrdad Afshari und Mahesh Velaga, dass ich entdecke einen Fehler (index=0) in meine aktuelle Umsetzung wäre das nicht entdeckt worden sonst..

InformationsquelleAutor der Frage Betamoo | 2011-01-01

  1. 53

    Die gute alte goto:

    restart:
foreach(Constrain c in Constrains)
{
   if(!c.Allows(a))
   {
      a.Change();
      goto restart;
   }
}

    Wenn Sie diagnostiziert gotophobia 100% der Zeit aus irgendeinem Grund (das ist nicht eine gute Sache, ohne einen Grund), können Sie versuchen, mit einer fahne statt:

    bool restart;
do {
   restart = false;
   foreach(Constrain c in Constrains)
   {
      if(!c.Allows(a))
      {
         a.Change();
         restart = true;
         break;
      }
   }
} while (restart);

    InformationsquelleAutor der Antwort Mehrdad Afshari

  2. 8

    Einer Weise, die Sie tun können, für die, wie du bereits erwähnt hast:

    neu starten, wie hier weiter oder brechen
    aber es startet wieder das foreach aus der
    Anfang ist Es wie die Einstellung der Zähler einer for-Schleife wieder auf 0

    Action a;
for(var index = 0; index < Constratins.Count; index++)
{
   if(!Constraints[index].Allows(a))
   {
      a.Change();
      index = -1; //restart
   }
}

    InformationsquelleAutor der Antwort Mahesh Velaga

  3. 8

    Zwar ein sehr Alter thread - keine Antworten bezahlt gebührend auf die Semantik des Codes:

    • Sie haben eine Kette von Einschränkungen auf a
    • Wenn a bricht einer von Ihnen, versuchen Sie einen anderen a und schieben, die durch die Kette.

    Dass a.Change() sollten getrennt von der constraint-checking-Schleife, die auch die Einhaltung der CQS-Prinzip:

    while (!MeetsConstraints(a))
{
    a.Change();
}

bool MeetsConstraints(Thing a)
{
    return Constraints.All(c => c.Allows(a));
}

    Kein goto, keine hässliche Schleifen, einfach und sauber. </self-zurück-slapping>

    InformationsquelleAutor der Antwort chiccodoro

  4. 4
    void Main()
{
    IEnumerable<Constrain> cons;
    SomeObject a;

    while(!TryChangeList(cons, a)) { }
}

//the name tryChangeList reveals the intent that the list will be changed
private bool TryChangeList(IEnumerable<Constrain> constrains, SomeObject a)
{
    foreach(var con in constrains)
    {
        if(!c.Allows(a))
        {
            a.Change();
            return false;
        }
    }
    return true;
}

    InformationsquelleAutor der Antwort Unmesh Kondolikar

  5. 0
    for (var en = Constrains.GetEnumerator(); en.MoveNext(); )
{
    var c = en.Current;
    if (!c.Allows(a))
    {
        a.Change();
        en = Constrains.GetEnumerator();
    }
}

    InformationsquelleAutor der Antwort Eivind T

Schreibe einen Kommentar