Génération du travailleur d'arrière-plan .NET

Question

Nous travaillons sur une application Windows qui doit périodiquement lancer des opérations, ce qui peut prendre un certain temps. Nous avons pris l'habitude d'exécuter ces opérations sur un BackgroundWorker, et d'écrire un WinForm rapide pour chaque opération, où vous passez au formulaire les paramètres nécessaires, le formulaire connecte le BackgroundWorker et fait l'appel de fonction, et le formulaire affiche la sortie (la barre de progression bouge, le texte se remplit avec les mises à jour, etc).

Évidemment, ce formulaire est très simple. La seule partie qui diffère vraiment entre les copies du formulaire est quelle méthode est appelée sur quel objet. Ce que nous aimerions faire, c'est le rendre générique, en prenant le formulaire, en passant un objet (ou null pour les appels statiques ?), un nom de fonction, et un tableau de paramètres, et en le faisant "partir" de là. Nous avons été en mesure de le faire avec Reflection. Ce que nous n'aimons pas dans le cas de Reflection, c'est l'absence de typage fort ; les erreurs d'orthographe de l'appel de méthode sont détectées au moment de l'exécution, et non de la compilation. Y a-t-il quelque chose de disponible aujourd'hui qui pourrait rendre cela plus élégant et plus robuste ? J'ai entendu des gens parler de choses comme les délégués et les arbres d'expression, mais je ne suis pas sûr que le premier s'applique et je suis encore un peu dans l'ignorance du second.

Answer 1

Créer un formulaire commun et lui passer un délégué pointant vers la méthode qu'il doit exécuter sur BackgroundWorker, serait une solution raisonnable.

Vous pouvez faire en sorte que le constructeur du formulaire prenne un délégué générique (Action pourrait être une bonne idée) comme argument, et passer une expression lambda dans le constructeur, qui correspond à la signature de Action). Ensuite, pour chaque action, il suffirait de spécifier l'expression lambda appropriée.

Rappelez-vous qu'une expression lambda peut capturer des variables locales, vous pourrez donc appeler la logique que vous avez utilisée auparavant et passer les mêmes paramètres.

Answer 2

Vous pouvez également vous intéresser aux fonctions Lambda. Je les utilise spécifiquement lorsque je travaille avec des génériques. Sinon, les délégués feront probablement l'affaire.

Answer 3

Une chose que vous pourriez faire est de créer plusieurs méthodes différentes (une pour les méthodes sans argument, une pour les méthodes avec un argument, etc.) comme ceci :

public static void DisplayForm(Action action) {
    DisplayFormUsingInvoke(action);
}

public static void DisplayForm<T>(Action<T> action, T param) {
    DisplayFormUsingInvoke(action, param);
}

public static void DisplayForm<T,U>(Action<T,U> action, T param1, U param2) {
    DisplayFormUsingInvoke(action, param1, param2);
}

...

Ensuite, vous pouvez avoir une méthode privée qui effectue réellement le travail, de manière similaire à votre méthode actuelle, mais qui n'est pas exposée au code client :

private static void DisplayFormUsingInvoke(Delegate d, params object[] parms) {
    // Edit this code to run it on the background thread, report progress, etc.
    d.DynamicInvoke(parms);
}

Ensuite, le code client appellera l'une des méthodes publiques qui imposera l'obligation de fournir le bon nombre et les bons types d'arguments.