Discussion :

[Chen norris]

Bonjour à tous,

Je suis confronté à un problème de mécanisme de programmation assez particulier : je travaille au développement d'une application en C# et dans laquelle certains boutons graphiques doivent activer diverses fonctions. Les boutons à créer sont stockés dans un fichier de configuration que je lis au début de mon programme (fichier du style "nom de bouton -> action à lancer"). Ma question est de savoir dans quel type de structure stocker proprement les boutons, de manière à stocker les fonctions associées à lancer.

Une première idée était de stocker une chaine contenant le nom de la fonction.
Exemple :
Classe "Bouton" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public class Bouton {
	String actionAssociee;
	public Bouton(String actionLancee) {
		actionAssociee = actionLancee;
	}

Code principal :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
...
List<Bouton> listeDeBoutons;
...
// ici, je lis mon fichier de config en
// extrayant nom de bouton et action 
// associée  et pour chaque bouton, je fais :
listeDeBoutons.Add(new Bouton(nomDeBouton));
...
if (boutonClique.actionAssociee.Equals("toto"))
	toto();

Le souci, c'est que ça n'est pas du tout générique puisque je suis obligé d'écrire en dur dans le code l'association entre le bouton "toto" et l'action lancée toto().

En fouinant un peu sur le net, je suis tombé sur les delegate, concept que je ne connaissais pas jusqu'à présent. Si j'ai bien tout compris suite à mes lectures, je peux avoir quelque chose du style :

Classe "Bouton" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
public class Bouton {
private delegate void action();
	action actionAssociee;
	public Bouton(String actionLancee) {
		actionAssociee = new action(actionLancee);
	}

Code principal :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
...
listeDeBoutons.Add(new Bouton(nomDeBouton));
...
boutonClique.actionAssociee();

Sauf qu'apparemment, je ne peux pas donner de chaine de caractères en paramètre lors de l'instanciation de Bouton. J'obtiens une erreur "actionLancee est une variable mais est utilisée comme une méthode". Le truc, c'est que je ne veux surtout pas donner explicitement de nom de méthode (ça ne me ferait au final que ré-écrire en dur l'association bouton->méthode).

Est-ce que vous auriez une idée de comment mettre en place un système qui me permette de gérer proprement tout ça ?

Merci d'avance pour vos explications.

[Bluedeep]

Tu as la possibilité d'utiliser la reflection pour récupérer la méthode à lancer (à condition bien sur d'avoir une association explicite - égalité de nom par exemple- entre l'action et la méthode utilisée).

Voir l'espace de nom System.Reflection et en particulier la méthode GetMethod de la classe Type.

[Chen norris]

Ouch… Complexe à comprendre mais alors très efficace comme concept. J'ai cherché de la doc sur le net par rapport à ce que tu me disais et je pense avoir trouvé mon bonheur. Je ne marque pas mon post résolu pour le moment : je reviendrai poster le détail de la solution.

Merci beaucoup en tous cas pour ce coup de pouce.

[ctxnop]

Attention tout de même avec la reflection, c'est un chouilla bourrin comme truc.
Ca répond parfaitement à ton besoin mais tu dois prendre quelques précautions.
En effet, si on imagine que tu code le truc de cette façon :

Code csharp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
public partial class MonFormulaire
    : Form
{
    private void LireFichier(string Chemin)
    {
        // Ici tu instancie tes ActionBouton et tu utilise la reflection
        // pour convertir "MonAction1" en un handler vers la méthode MonAction1
    }
 
    // ....
 
    // Ici l'action est donc une méthode de MonFormulaire
    private void MonAction1()
    {
        // ....
    }
 
    // Ci-dessous une méthode qui n'est pas une action disponible
    // et qui sert à drop une base de donnée
    private void DropDatabase()
    {
        // ....
    }
 
}

Voila, tout ca fonctionnera parfaitement, mais si tu ne fais pas attention un utilisateur mal attentionné pourra mettre comme action "DropDatabase" ce qui serait une catastrophe.

De la même manière, si tu code trop générique (histoire de permettre par exemple de passer un paramètre à l'action), un détournement pourrait être fait pour faire exécuter n'importe quoi à ton formulaire.

Je te conseil l'utilisation d'une classe (surement static) contenant uniquement les méthodes d'action liables. Lors de l'exécution de l'action du passera en paramètre ce qu'il faut (peut être ton formulaire ?). La recherche par reflection devra ensuite être faite uniquement dans le périmètre de la classe en question, ainsi on ne pourra pas détourner le fonctionnement.

[Bluedeep]

Voila, tout ca fonctionnera parfaitement, mais si tu ne fais pas attention un utilisateur mal attentionné pourra mettre comme action "DropDatabase" ce qui serait une catastrophe.

Il peut par exemple aisément sécuriser la chose en ajoutant une classe attribut (vide, avec un nom du style "ValidCustomActionAttribute") comme attribut de méthode pour les méthodes susceptibles d'être appelée et contrôler la présence de cet attribut avant de valider l'association nom action - méthode.


Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
class MyClass
{
 
[ValidCustomAction]
private void MyActionMethod()
{
}
private void checkMethods(Type myType)
{
MethodInfo methodInfo = myType.GetMethod("MyActionMethod", false);
Attribute validationAttribute = methodInfo.GetCustomAttributes(typeof(ValidCustomActionAttribute), false);
if (validationAttribute == null)
{
// Methode non autorisée
}
}
}
 
class ValidCustomActionAttribute : Attribute
{
}

[ctxnop]

Il peut par exemple sécuriser la chose en ajoutant une classe attribut (vide, avec un nom du style "ValidCustomActionAttribute") comme attribut de méthode pour les méthodes susceptibles d'être appelée et contrôler la présence de cet attribut avant de valider l'association nom action - méthode.

Oui aussi, c'est une autre solution. Je voulais surtout attirer son attention sur le fait qu'une liaison directe engendre sensiblement le même type de problème que l'injection SQL : une utilisation détournée qui exécute du code non souhaité.