Discussion :

[BLooDBuRNiNG]

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 :

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

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 :

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
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 :

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

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

[ericlm128]

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

[ericlm128]

Cela compile :

Code :

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

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

[ericlm128]

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

Code :

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

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];
        }

[BLooDBuRNiNG]

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 :

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

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

  Code :

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

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