Liste ForEach break

est-il un moyen de sortir de la boucle foreach de la méthode d'extension? Le "break" mot-clé ne reconnaît pas l'extension de la méthode de validité portée à la pause.

//Doesn't compile
Enumerable.Range(0, 10).ToList().ForEach(i => { System.Windows.MessageBox.Show(i.ToString()); if (i > 2)break; });

Edit: supprimé "linq" de la question

note le code est juste un exemple pour montrer pause ne fonctionne pas dans la méthode d'extension... vraiment ce que je veux, c'est pour l'utilisateur d'être en mesure d'interrompre le traitement d'une liste.. le thread d'INTERFACE utilisateur a un abandon de la variable et pour la boucle juste des pauses lorsque l'utilisateur appuie sur un bouton annuler. Maintenant, j'ai un normal pour une boucle, mais je voulais voir si c'était possible de le faire avec la méthode d'extension.

source d'informationauteur tbischel

  1. 17

    Il est probablement plus exact de les appeler cela un List<T> Foreach contre une LINQ.

    Dans les deux cas, si non il n'y a pas de moyen de sortir de cette boucle. Principalement parce que ce n'est pas vraiment une boucle par dire. C'est une méthode qui prend un délégué qui est appelée à l'intérieur d'une boucle.

    La création d'un ForEach avec une pause de capacité est assez simple si

    public delegate void ForEachAction<T>(T value, ref bool doBreak);
public static void ForEach<T>(this IEnumerable<T> enumerable, ForEachAction<T> action) {
    var doBreak = false;
    foreach (var cur in enumerable) {
        action(cur, ref doBreak);
        if (doBreak) {
            break;
        }
    }
}

    Vous pouvez réécrire votre code comme le suivant 

    Enumerable.Range(0,10)
    .ForEach((int i,ref bool doBreak) => {
        System.Windows.MessageBox.Show(i.ToString()); 
        if ( i > 2) {doBreak = true;}
    });
  2. 11

    Je recommande d'utiliser TakeWhile.

    Enumerable.Range(0, 10).TakeWhile(i => i <= 2).ToList().ForEach(i => MessageBox.Show(i.ToString()));

    Ou, à l'aide de Rx:

    Enumerable.Range(0, 10).TakeWhile(i => i <= 2).Run(i => MessageBox.Show(i.ToString()));
  3. 3

    Pourquoi ne pas utiliser Where?

    Enumerable.Range(0, 10).Where(i => i <= 2).ToList().ForEach(...)
  4. 1

    Essayer un "return" au lieu de "casser"; c'est une fonction de délégué et pas une seule boucle.

    Essayer:

    Enumerable.Range(0, 10).ToList().ForEach(i => { System.Windows.MessageBox.Show(i.ToString()); if (i > 2) return; });
  5. 0

    Pourquoi ne pas utiliser foreach ? ...

    PS: Juste une blague, et comme tu le dit, je comprends l'idée d'essayer de voir comment faire avec Linq (et googlé ici pour la même raison) ... maintenant pour l'entretien/l'état de préparation des raisons dans le code de production suppose une simple foreach est assez bon parfois.

  6. 0

    Pour moi-même, j'ai utilisé Linq Select + FirstOrDefault. Transformer le "chacun" dans la liste, mais depuis que nous demandons pour la Première, il s'arrête en les transformant après avoir trouvé la première qui correspond à.

    var thingOption = list.Select(thing => AsThingOption(thing))
.FirstOrDefault(option => option.HasValue) ?? Option.None<MyThing>;

    Comme vous pouvez le voir je suis transformant chaque chose dans une Option et ma méthode AsThingOption peut réussir à transformer et quand il ne nous arrêtons une itération sur la liste. Si les conditions à l'intérieur AsThingOption méthode ne jamais réussir à transformer, puis à la fin résultat n'en est pas.

    Espère que ça aide!

  7. 0

    Pourquoi ne pas throw new Exception("Specific message") ou de l'utilisation d'un indicateur booléen?

    DataTable dt = new DataTable();
bool error = false;

try
{
    dt.AsEnumerable().ToList().ForEach(dr =>
    {
        if (dr["Col1"].ToString() == "")
        {
            error = true;
            throw new Exception("Specific message");
        }
        else 
            //Do something
    });
}
catch (Exception ex)
{
    if (ex.Message == "Specific message" || error) 
        //do something
    else
        throw ex;
}
  8. 0

    J'ai un cas où j'ai besoin de boucle actions jusqu'à ce qu'une condition est fausse et chaque action peut modifier la valeur utilisée pour suivre l'état. Je suis venu avec cette variante de la .TakeWhile(). L'avantage ici est que chaque élément de la liste peut participer dans une certaine logique, la boucle peut être interrompue sur une condition n'est pas directement lié à l'élément. 

    new List<Action> {
    Func1,
    Func2
}.TakeWhile(action => {
    action();
    return _canContinue;
});