Refactoring de l'instruction foreach imbriquée

J'ai une méthode avec un imbriquée foreach collection (itération un ensemble d'objets, puis regarder à l'intérieur de chaque objet). J'ai vu dans un livre, un bon motif pour faire ce beaucoup plus élégant, mais ne peut se souvenir de l'exemple de code. Comment pourrais-je faire de ce plus à l'ordre?

Le code est juste un typique imbriquée foreach déclaration, donc je n'ai pas fourni un exemple de code.

source d'informationauteur dotnetdev

  1. 6

    La solution la plus évidente consiste à aplatir dans les méthodes.

    Vieux:

    void SubmitOrders()
{
    var orders = GetOrders();
    foreach (Order o in orders)
    {
        foreach (OrderDetail d in o.Details)
        {
            //Blah...
        }
    }
}

    Nouveau:

    void SubmitOrders()
{
    var orders = GetOrders()
    foreach (Order o in orders)
    {
        SubmitOrder(o);
    }
}

void SubmitOrder(Order order)
{
    foreach (OrderDetail d in order.Details)
    {
        //Blah...
    }
}

    D'autres réponses ici semblent être concentrés sur Linq, et je suis d'accord que si vos boucles ont pas d'effets secondaires (c'est à dire que vous êtes juste essayer d'en extraire des informations à partir de la boucle de plus bas niveau), alors vous pouvez probablement réécrire l'ensemble de la chose à l'aide d'un ou de deux Linq simple consolidés. Si les effets secondaires sont impliqués, puis il suffit de suivre l'épreuve du temps la pratique de sous-routines.

  2. 11

    Vous allez avoir à être plus précis sur ce que tu veux dire à propos des "plus élégant", comme l'OMI, il n'y a rien de particulièrement inélégante sur un imbriquée foreach.

    Cela étant dit, l'extension LINQ méthodes .NET 3.5 et ci-dessus peuvent vous aider (plus précisément SelectMany).

    public class Foo
{
    public List<string> Strings { get; set; }
}

...

List<Foo> foos = new List<Foo>();

foreach(string str in foos.SelectMany(f => f.Strings))
{
    ...
}
  3. 4

    Avant:

    foreach(Customer c in Customers)
{
  foreach(Order o in c.Orders)
  {
    o.Dance();
  }
}

    Après:

    foreach(Order o in Customers.SelectMany(c => c.Orders))
{
  o.Dance();
}
  4. 1

    Vous pouvez utiliser LINQ SelectMany opérateur:

    foreach (var bar in model.FooCollection.SelectMany(f => f.Bars))
{
  //Do Stuff
}

    http://www.hookedonlinq.com/SelectManyOperator.ashx

  5. 1

    Il est difficile de donner une réponse en dehors de tout contexte ou de l'extrait de code. Cependant, Martin Fowler a un très bon article sur la refactorisation des boucles en LINQ pipelines qui peut être trouvé ici (apprécier c'est une vieille question, alors j'espère que les futurs lecteurs bénéficieront!).

  6. 0

    Êtes-vous penser à quelque chose comme ça?

    public class YourObject{
   public List<OtherObject> Others { get; set; }
}

public class OtherObject{
   public void DoIt(){}
}

var theList = new List<YourObject>();

theList.ForEach(yo => yo.Others.ForEach(oo => oo.DoIt()));