Comment factoriser plusieurs extensions avec différents paramètres Func avec le même résultat

Question

Je suis nouveau à Func/Action/prédicats et que vous voulez savoir quelle est la meilleure façon de factoriser mon code comme je potentiellement avoir beaucoup de code répété.

J'ai créé 2 méthodes d'extension qui prennent un paramètre Func (toujours retour booléens):

public static void MyExtension<T>(this T obj, Func<T, bool> predicate) 
    { 
     do 
     { 
      //function code 
     } while (predicate(obj)); 
    } 
    public static void MyExtension<T1, T2>(this T1 obj, T2 OtherObject, Func<T1, T2, bool> predicate) 
    { 
     do 
     { 
      //function code 
     } while (predicate(obj, OtherObject)); 
    } 

Ce que je veux, est le code que la boucle do/while une fois que je pourrais avoir beaucoup de fonctions qui ne générera qu'un Func différent mais qui voudra tous exécuter la même boucle do/while.

Je pensais quelque chose comme ça, qui prend un paramètre Func et fonctionne sur chaque boucle. Le code dans la boucle ne se soucie pas des types passés dans le Func.

public static void DoLoop(Func predicate) 
    { 
     do 
     { 
      //function code 
     } while (predicate); 
    } 

Mais cela ne marche clairement pas. Est-ce que quelqu'un sait comment résoudre cela, ou est-ce que je fais quelque chose de fondamentalement faux?

Le résultat final est que je veux appeler le code comme ci-dessous:

 var Obj = new MyObj(); 
     Obj.MyExtension((x) => x.Prop1.Contains("string")); 

     var OtherObj = new MyObj(); 
     Obj.MyExtension(OtherObj, (x,y) => x.Prop1.Contains("string") && y.Prop1.Contains("other")); 

Merci.

Answer 1

Étant donné que vos méthodes génériques sont paramétrés sur un nombre différent de types génériques, vous devez garder toutes les signatures de fonction en place pour que le code appelant à compiler. Cependant, vous pouvez déplacer la mise en œuvre dans une méthode d'assistance commune pour réduire le code répété:

// This is your single implementation 
private static void DoLoop(Func<bool> predicate) { 
    do { 
     //function code 
    } while (predicate()); 
} 
// These are the wrappers 
public static void MyExtension<T>(this T obj, Func<T, bool> predicate) { 
    DoLoop(() => predicate(obj)); 
} 
public static void MyExtension<T1, T2>(this T1 obj, T2 OtherObject, Func<T1, T2, bool> predicate) { 
    DoLoop(() => predicate(obj, OtherObject)); 
} 

wrappers construisent paramètre moins prédicat, et le transmettre à la méthode DoLoop privée qui fournit la mise en œuvre.