EventManager : Generic Action Contraintes

Version imprimable

Bonjour messieurs,

Je rencontre une problématique sur un manageur d'évênement sur lequel je travaille actuellement, actuellement il n'y a pas de contraintes pour définir qu'un type générique est une delegate, deplus il n'y a pas d'interface permettant d'avoir les opérateurs +=, -=.

Par conséquent je cherche à faire compiler cette ligne : this.events[EnumHelper.GetIndex<EnumType>(enumeration)] += action;

Auriez-vous des idées de comment la faire compiler ?

Voici mon code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using System.Collections.Generic;
using System;
 
public static class EnumHelper
{
    public static int GetIndex<EnumType>(EnumType enumeration) where EnumType : struct, IConvertible
    {
        return Convert.ToInt32(enumeration);
    }
 
    public static int Count<EnumType>() where EnumType : struct, IConvertible
    {
        return System.Enum.GetValues(typeof(EnumType)).Length;
    }
}

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
using System.Collections.Generic;
using System;
 
public abstract class AEventManager<EventType, EnumType> 
    where EnumType : struct, IConvertible
    where EventType : class, Action<int>
{
    protected EventType[] events;
 
    public AEventManager()
    {
        if (!typeof(EnumType).IsEnum)
            throw new ArgumentException("EnumType must be an enumerated type");
 
        this.events = new EventType[EnumHelper.Count<EnumType>()];
    }
 
    protected EventType GetEvent(EnumType enumeration)
    {
        return this.events[EnumHelper.GetIndex<EnumType>(enumeration)];
    }
 
    public void SubcribeToEvent(EnumType enumeration, EventType action)
    {
        this.events[EnumHelper.GetIndex<EnumType>(enumeration)] += action;
    }
 
    //Unsubscribe, abstract callDelegate(EnumType enumeration, ... templateVarags)..
}

Code:

1
2
3
public class EventManager : AEventManager<Action<int>, EEvent>
{
}

22/03/2016, 19h56
ericlm128

Première piste :
Impossible d'appliquer l'opérateur '+=' aux opérandes de type 'EventType' et 'EventType'

Cela compile :

Code:

1
2
            EventType ev = GetEvent(enumeration);
            ev = action;

En faite ça parait normal en simplifiant le code, ça revient à faire ça :

Code:

1
2
3
4
5
6
7
            int[] tab = { 10, 20, 30 };
            get(tab, 2) = 5;
 
        private int get(int[] tab, int idx)
        {
            return tab[idx];
        }

Bonjour eric,

Je vais énumérer les 2 défauts de ta démarche :

L'intérêt d'une action (delegate) et qu'il contiend les opérateurs +=, -=, ceci signifie que l'on est pas limité à une seule action mais plutôt un groupe d'action.
Tu utilise un int pour faire le lien directement avec l'index de ton tableau d'evênements, c'est légèrement plus optimisé mais sachant que le cast d'un int vaut environ 1-2 cycles soit vraiment peu de choses, je souhaite rendre mon code beaucoup plus verbeux. Par exemple
Code:

1 2 3 4 AEventManager<Action<int, float>, EEvent> eventManager = new AEventManager<Action<int, float>, EEvent>(); eventManager.SubscribeToEvent(EEvent.NomDunIndexDeCetteEnumeration, uneFonctionPrenantEnParametreUnIntEtUnFloat);
Code:

1 2 3 4 5 6 void toto() { eventManager.CallDelegate(EEvent.NomDunIndexDeCetteEnumeration); }