Factorisation du traitement du squelette (C#)

Question

Existe-t-il une construction de langage en C# qui permette l'abstraction du traitement «externe» en boucle (ou autre)?

J'ai une structure imbriquée assez simple (listes de listes d'ints say) et le code pour "tourner" dans chacun des niveaux les plus bas. Le code n'est pas compliqué (ni particulièrement long) mais j'ai plusieurs fonctions qui ont besoin d '"interagir" avec le niveau le plus bas indépendamment et qui ont simplement copié le squelette de la boucle pour le faire. On dirait un gâchis pour moi.

foreach (list in outerlists) 
    ... a few random lines of structure traversing 
    foreach (int in list) 
     do something simple to int 

Ceci est évidemment réduite par exemple, mais mon monde réel est similaire - je finis par copier le traitement externe à plusieurs reprises pour changer de façon relativement peu de lignes intérieures de travail.

Ma tentative de solution consiste à créer une méthode de «traitement» qui contient les boucles et qui prend un paramètre d'énumération (ou quelque chose) pour lui indiquer la fonction interne à appeler. Ensuite, mettez une instruction switch au niveau "do something" qui appelle la sous-fonction correcte. Suis-je sur la bonne voie ou existe-t-il un moyen plus facile? Je pourrais me débarrasser de l'instruction switch avec un concept de pointeurs de fonction (juste passer un pointeur de fonction dans la boucle de traitement et l'appeler au niveau do quelque chose) mais je ne sais pas si cela est possible en C#?

Answer 1

(élaborer un peu sur la réponse de Oded)

En supposant que vous voulez toujours itérer de la même façon et que la seule différence entre les années foreach collé copie est le bloc emboîtée la plus interne, vous pouvez alors encapsuler toutes les boucles en une méthode:

public void DoStuffOnInnerElements (Action<int> theStuffToDo) 
{ 
    foreach (var subList in outerLists) 
    { 
     // a few random lines here... 
     foreach (int item in subList) 
     { 
      theStuffToDo(item); 
     } 
    } 
} 

L'action peut être l'un des formats que C# accepte pour delegates (un délégué est la réponse de C# à des pointeurs de fonction C/C++):

// Lambdas 
DoStuffOnInnerElements((i) => Console.WriteLine(i)); 
// Methods 
DoStuffOnInnerElements(My_Void_xxx_Int_Method); 
DoStuffOnInnerElements(new Action<int>(Console.WriteLine)); 
// anonymous delegates 
DoStuffOnInnerElements(delegate(int i) { Console.WriteLine(i); }); 
// etc. 

Answer 2

Vous pouvez passer un Action delegate - ce sera la fonction effectuant l'opération réelle dans la boucle externe.