Delegate vraiment générique

Bonjour,

Je reviens a la charge pour une question de plus sur la généricité en C#, je penses que c'est la dernière :p

Voici le contexte :

J'ai créé 2 classes pour ce test unitaire :
- GenericCallbacks :
Elle stock un pointeur de méthode et l'appel quand on lui demande.

- TestDelegate :
Elle crée des GenericCallbacks ainsi que les méthodes de test a attacher aux delegates.

Voici le code complet compilable, j'exposerai le problème après :

GenericCallbacks :

Code:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace TestGenericDelegate
{
    class GenericCallbacks
    {
        private Delegate action;
 
        private int x;
        private int y;
 
        public delegate void Callback();
        public delegate void Callback2(int x, int y);
        /*
         * [...]
         * Un grand nombre de delegate au prototypage different
         * Pas tres propre..
         */
 
        public GenericCallbacks(Delegate Action)
        {
            this.action = Action;
            this.x = this.y = 0;
        }
 
    //    public GenericCallbacks(Callback2 Action)
     //   {
     //       this.action = Action;
     //       this.x = this.y = 5;
     //   }
 
        public void Invoke()
        {
            /* Apres diverses operations sur x et y j'ai moyen de savoir en quoi caster */
            if (this.x != 0 && this.y != 0)
            {
                ((Callback2)action).Invoke(x, y);
            }
            else
            {
                ((Callback)action).Invoke();
            }
        }
    }
}

TestDelegate :

Code:

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
27
28
29
30
31
32
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace TestGenericDelegate
{
    class TestDelegate
    {
        public void Method1()
        {
            Console.WriteLine("Method 1.");
            return;
        }
 
        public void Method2(int x, int y)
        {
            Console.WriteLine("Method 2 : {0}, {1}.", x, y);
            return;
        }
 
        public TestDelegate()
        {
            GenericCallbacks unitTest = new GenericCallbacks(Method1);
            GenericCallbacks unitTest2 = new GenericCallbacks(Method2);
 
            unitTest.Invoke();
            unitTest2.Invoke();
        }
    }
}

Un main de test :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace TestGenericDelegate
{
    class Program
    {
        static void Main(string[] args)
        {
            TestDelegate testDelegate = new TestDelegate();
            Console.ReadKey(true);
        }
    }
}

La problématique est la suivante :
Comment éviter de créer autant de constructeurs que de type de delegate dans la classe GenericCallbacks ?

Dans l'exemple je n'en ai que 2, mais dans le vrai programme qui me pose soucis j'en ai environ 10, en sachant que j'ai 1 surcharges pour chacun des types de delegates ce qui donne 20 surcharge de la même méthode d'ajout !

Dans mon cas, même si c'est moche, ca peut marcher, mais je n'ose pas imaginer le développeur qui se retrouve avec 250 prototypes possibles pour ses delegates.

J'ai essaye de faire prendre au constructeur un type System.Delegate mais ca ne fonctionne pas.
J'ai beau chercher un type générique capable de contenir un pointeur sur méthode mais je n'en trouve pas.

Voila, merci pour votre aide !