Méthodes de refactorisation invoquant des delgates avec différentes signatures de paramètres

Question

Existe-t-il un modèle que je pourrais appliquer pour refactoriser ce code? La seule différence entre les deux méthodes est que cette méthode prend un paramètre supplémentaire et le transmet au délégué?

J'ai découvert que les délégués ne peuvent pas prendre de signatures de méthodes surchargées. Comment pourrais-je ajouter un niveau supplémentaire d'indirection? :)

public static void ProcessFolder(
    ProcessFolderDelegate processFolderDelegate 
) 
{ 
    using (var esb = ExchangeService.GetExchangeServiceBinding()) 
    { 
     var contactFolder = FolderService.GetPublicFolder(esb, 
      Properties.Settings.Default.ExchangePublicFolderName); 
     processFolderDelegate(esb, contactFolder); 
    } 
} 

public static void ProcessContact( 
    ProcessContactDelegate processContactDelegate, 
    Contact contact //extra param 
) 
{ 
    using (var esb = ExchangeService.GetExchangeServiceBinding()) 
    { 
     var contactFolder = FolderService.GetPublicFolder(esb, 
      Properties.Settings.Default.ExchangePublicFolderName); 
     processContactDelegate(esb, contactFolder, contact); //extra param 
    } 
} 

Answer 1

public delegate void Action(TYPE_OF_ESB esb, TYPE_OF_CONTACT_FOLDER contact folder); 
    private static void Process(Action action) 
    { 
     using (var esb = ExchangeService.GetExchangeServiceBinding()) 
     { 
      var contactFolder = FolderService.GetPublicFolder(esb, Properties.Settings.Default.ExchangePublicFolderName); 
      action(esb, contactfolder); 
     } 
    } 

Process((esb, contactfolder)=>processFolderDelegate(esb, contactFolder)); 
Process((esb, contactfolder)=>processContactDelegate(esb, contactFolder, contact)); 

Answer 2

Non, le code que vous avez posté est en fait une méthode très succincte pour appliquer ce modèle. Vous n'allez pas trouver un moyen de terser à moins qu'il y ait une façon d'abstraire le type de méthode appelée, ou en supprimant tout type de sécurité, que je ne recommanderais pas

Answer 3

Vous pouvez utiliser des méthodes anonymes ou des lambdas comme ceci:

delegate void ProcessDelegate<T>(T param); 
. 
. 
public static void Process<T>(ProcessDelegate<T> processDelegate) 
{ 
    using (var esb = ExchangeService.GetExchangeServiceBinding()) 
    { 
     var contactFolder = FolderService.GetPublicFolder(esb, 
      Properties.Settings.Default.ExchangePublicFolderName); 
     processDelegate(contactFolder); 
    } 
} 

puis appeler la méthode comme celui-ci

Process(contactFolder => MyMethod(esb, contactFolder)); 
Process(contactFolder => MyMethod(esb, contactFolder, contact)); 

Où MyMethod est la méthode réelle que vous appelez, vous contenir dans votre expression lambda plutôt que d'un délégué. Pensez que quelque chose comme ça peut fonctionner?

Answer 4

public static void ProcessFolder(ProcessFolderDelegate del) 
{ 
    Process((b, f) => del(b, f)); 
} 

public static void ProcessContact(ProcessContactDelegate del, Contact contact) 
{ 
    Process((b, f) => del(b, f, contact)); 
} 

private static void Process(
    Action<ExchangeServiceBinding, ContactsFolderType> action) 
{ 
    // i've guessed that esb is of type ExchangeServiceBinding 
    // and that contactFolder is of type ContactsFolderType 
    // if that's not the case then change the type parameters 
    // of the Action delegate in the method signature above 

    using (var esb = ExchangeService.GetExchangeServiceBinding()) 
    { 
     var contactFolder = FolderService.GetPublicFolder(
      esb, Properties.Settings.Default.ExchangePublicFolderName); 
     action(esb, contactFolder); 
    } 
}