Discussion :

[brachior]

Bonjour,

J'ai besoin de maintenir une Factory au fil du temps sans devoir toucher au code.
Pour jouer avec cette Factory, je pensais utiliser un Enum
(clarté dans le code et pour l'utilisation)

Mais voila,
On ne peut pas modifier dynamiquement le contenu d'un Enum
(il est spécifié à la compilation)

En Java (car c'est de là que je viens ^^)
J'utilisais une interface de marquage,
Les Enums l'implémentaient et c'était tout bon,
(une nouveauté dans la Factory + un nouvel Enum fournit = PROFIT !!!)

En C#, les Enums ne peuvent implémenter/hériter d'autre objet.
Je me retrouve bloqué ^^'

Quelqu'un aurait une idée de comment faire en C# ?

[NicoL__]

Salut,
Effectivement il y a une sacrée différence entre java et c# avec les enum. En java un Enum est une classe pas en c#.
Donc pour toi le plus simple si tu veux reproduire le fonctionnement de en c# va falloir faire des classes pour chaque valeur de l'enum qui hérite de la même classe abstraite.
En c# l'enum est un type il est bien pratique et simple mais le code est dans le case. Alors qu'en java tu peux mettre le code dans l'enum lui même.

[brachior]

Hum le truc lourding Oo

Bon, je vais faire une AbstractFactory dans ce cas =/

[brachior]

Bonjour,
Bon je reviens à la charge sur mon problème d'interface de marquage.

J'essaye de trouver un moyen simple de reproduire ce mécanisme
Et j'aimerai votre avis ^^

Admettons une Factory nommée en circonstance.
J'y stocke une valeur, ici un int,
En fonction d'une clé, ici une string,
J'utilise une string au lieu d'une classe spéciale
Pour utiliser tous les mécanismes déjà implémentés par le Framework,
Qui seront (quasi) forcement mieux que si ça venait de moi ^^
(hashcode, equals, ...)

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
 
public class Factory
{
  public Dictionary<string, int> dico { get; private set; }
 
  public Factory()
  {
    dico = new Dictionary<string, int>();
  }
 
  public void add(CType k, int v)
  {
    dico.Add(k, v);
  }
 
  public int get(CType type)
  {
    return dico[type];
  }
}

La classe CType crée la "constante" à proprement parlé.
Elle utilise la reflexion pour distinguer les différents (faux) "enum"

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
30
31
32
33
34
 
public class CType
{
  private static int index = 0;
 
  private readonly string type;
  private readonly int val;
 
  public string Name { get; private set; }
  public string FullName { get { return type + "." + Name; } }
 
  public CType(string value)
  {
    this.type = new StackTrace().GetFrame(1)
      .GetMethod().DeclaringType.FullName;
    this.Name = value;
    this.val = index++;
  }
 
  public override string ToString()
  {
    return Name;
  }
 
  public static implicit operator string(CType type)
  {
    return type.FullName;
  }
 
  public static implicit operator int(CType type)
  {
    return type.val;
  }
}

LType1 et LType2 sont deux exemples de (faux) "enum"

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public class LType1
{
  public static CType UN = new CType("un");
  public static CType DEUX = new CType("deux");
  public static CType TROIS = new CType("trois");
}
 
public class LType2
{
  public static CType QUATRE = new CType("quatre");
  public static CType CINQ = new CType("cinq");
  public static CType SIX = new CType("six");
}

Le test suivant affiche les valeurs du dictionnaire
Ainsi que la façon dont ils sont stockés.

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
30
31
32
 
public class Test
{
  public static void main()
  {
    Factory f = new Factory();
    f.add(LType1.UN, 6);
    f.add(LType1.DEUX, 0);
    f.add(LType1.TROIS, 2);
    f.add(LType2.QUATRE, 3);
    f.add(LType2.CINQ, 3);
    f.add(LType2.SIX, 5);
    f.add(new CType("sept"), 10);
 
    Console.WriteLine("{0}:{1} - {2}:{3} _ {4}:{5}",
      LType1.UN, f.get(LType1.UN),
      LType1.DEUX, f.get(LType1.DEUX),
      LType1.TROIS, f.get(LType1.TROIS));
    Console.WriteLine("{0}:{1} - {2}:{3} _ {4}:{5}",
      LType2.QUATRE, f.get(LType2.QUATRE),
      LType2.CINQ, f.get(LType2.CINQ),
      LType2.SIX, f.get(LType2.SIX));
    Console.WriteLine("{0}:{1}",
      new CType("sept"), f.get(new CType("sept")));
    Console.WriteLine();
 
    foreach (string s in f.dico.Keys)
    {
      Console.WriteLine(s);
    }
  }
}

Ça affiche :

un:6 - deux:0 _ trois:2
quatre:3 - cinq:3 _ six:5
sept:10

Archi_II.LType1.un
Archi_II.LType1.deux
Archi_II.LType1.trois
Archi_II.LType2.quatre
Archi_II.LType2.cinq
Archi_II.LType2.six
Archi_II.Program.sept



Allez y, grondez moi ^^

Juste pour rappel,
Je recherche un moyen simple, efficace, sécurisé et performant
(rien que ça ^^)
Pour accéder à des données évolutives ...

EDIT : ajout d'un test et le résultat du test ^^

[NicoL__]

Je ne te suis qu'à moitier. C'est un étrange truc que tout cela, une factory qui n'est autre qu'un dictionnaire, des éléments fourni par la factory ne sont pas instancié mais stocké dans le dico... bref surement que les notations ne correspondent pas au pattern et au standard.
Si tu veux faire de 'faux' enum qui ressemble à java et qui implémente un interface de marquage. Et bien il suffit de créer une classe qui implémente cette interface, et qui possède quelques propriétés (un entier et une string) pour gérer les instances, pourquoi pas les utiliser de façon static comme tu le fais. Le dictionnaire et la factory ne me semble utile ici.

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
30
31
32
33
34
35
36
37
38
 
public class MonEnum : IMonMarquage
{
 
  public static readonly MonEnum UN = new MonEnum ("UN",1);
  public static readonly MonEnum DEUX= new MonEnum ("DEUX",2);
  public static readonly MonEnum TROIS= new MonEnum ("TROIS",3);
  public static readonly MonEnum QUATRE= new MonEnum ("QUATRE",4);
  public static readonly MonEnum CINQ= new MonEnum ("CINQ",5);
 
  private readonly string name;
  private readonly int value;
 
 
 
  public CType(string name, int val)
  {
        name= name;
        value= val;
  }
 
  public override string ToString()
  {
     return name;
  }
 
  public static implicit operator string(CType type)
  {
    return this.name;
  }
 
  public static implicit operator int(CType type)
  {
     return this.value;
  }
 
/*TODO:IMPLEMENTER LES METHODES DE MARQUAGE...*/
}

[brachior]

La valeur que je mentionne n'est pas un int en fait.

C'est un Type que j'instancie à la demande.

J'ai besoin d'une Factory pour rassembler un ensemble d'éléments proprement
(un seul objet d'accès, le seul qui contrôle le tout)
Le dictionnaire me permet de rechercher en temps constant amorti un élément
Et aussi d'éviter les conflits.

Mon but ultime (^^) est de pouvoir gérer
La fabrication de composant simplement
Et pouvant être mise à jour
(la fabrication pas le composant ^^)
Dans le futur sans devoir toucher au code
(à la manière d'un plugin)