Discussion :

[gege2061]

Bonjour,

J'ai conscience que ce que je souhaite faire et un brin tordu, mais je n'ai pas trouvé de solution plus robuste.

Le but est d'avoir une classe de base qui implémente le pattern Factory dont d'autres classes pourront hériter tout en ayant un aspect différent (page à onglet ou tree view).

Voilà un 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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
using Gtk;
using System.Collections.Generic;
 
class Factory<G, H> where G : new()
{
    private static Factory<G, H> instance;
 
    protected Factory()
    {
    }
 
    public static Factory<G, H> get_instance()
    {
        if (instance == null)
        {
            instance = new Factory<G, H>();
        }
        return instance;
    }
}
 
class TreeView
{
}
 
class Project
{
}
 
class ProjectFactory : Factory<Gtk.TreeView, Project>
{
}
 
class Test
{
    static void Main(string[] args)
    {
        ProjectFactory factory = ProjectFactory.get_instance();
    }
}

Ce qui me permettrai d'avoir un gestionnaire de fichier :

Code :

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

1
2
3
class FileFactory : Factory<Gtk.Notebook, File>
{
}

Sachant que les gestionnaires proposent des méthodes open, save, ... qui ne sont que appeler les méthodes des objets usinés (H.open, H.save, ...).

Donc je souhaiterai savoir si ceci est faisable en C# (mon code ne compile pas) ou si vous avez une idée moins tordu ?

[ced600]

Soit tu ne connais pas les classes abstraites, soit tu as fait une erreur dans l'utilisation du design Factory.
Il n'est pas simple à comprendre, et on s'enmèle vite les pinceaux
Wiki te propose une description et un exemple de code (C# et autres langages) de ce patron de conception :
http://fr.wikipedia.org/wiki/Fabriqu...eption%29#C.23

Si tu veux que l'on te propose une solution moins tordus peux tu nous en dire un peu plus sur ce que tu souhaites faire ?

[Keihilin]

Je pense avoir compris ce que tu souhaites faire et je serai tenté de dire que oui, c'est faisable.

Par contre, je ne suis pas convaincu que ton approche soit la plus simple...mais j'attend que tu donnes plus de précisions.

Au passage, tu travailles en 2.0 ou en 3.5 ?

[gege2061]

Soit tu ne connais pas les classes abstraites, soit tu as fait une erreur dans l'utilisation du design Factory.
Il n'est pas simple à comprendre, et on s'enmèle vite les pinceaux
Wiki te propose une description et un exemple de code (C# et autres langages) de ce patron de conception :
http://fr.wikipedia.org/wiki/Fabriqu...eption%29#C.23

Beuh si j'connais les classes abstraites, c'est juste leur utilisation qui m'échappe un peu

Effectivement mon pattern est incomplet, avec la méthode abstraite createObject ça devrait simplifier les choses

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
39
40
41
42
43
44
45
46
47
48
49
using Gtk;
using System.Collections.Generic;
 
class Factory<G> where G : new()
{
    private static Factory<G> instance;
 
    protected Factory()
    {
    }
 
    public static Factory<G> get_instance()
    {
        if (instance == null)
        {
            instance = new Factory<G>();
        }
        return instance;
    }
 
    public virtual Object create_object()
    {
        return new Object();
    }
}
 
class Object
{
}
 
class Project : Object
{
}
 
class ProjectFactory : Factory<Gtk.TreeView>
{
    public override Object create_object()
    {
        return new Project();
    }
}
 
class Test
{
    static void Main(string[] args)
    {
        ProjectFactory factory = ProjectFactory.get_instance();
    }
}

Si tu veux que l'on te propose une solution moins tordus peux tu nous en dire un peu plus sur ce que tu souhaites faire ?

J'ai abordé ce point dans ma question : factoriser le code de deux factory

Plus concrètement :

• D'un côté j'ai une classe ProjectFactory qui hérite des TreeView et qui me permet de gérer les projects d'un IDE
• De l'autre une classe DocumentFactory qui est un Notebook et gère les fichiers

[gege2061]

Au passage, tu travailles en 2.0 ou en 3.5 ?

Aucun des deux J'utilise un langage C#-like : Vala. Je pense que je peux facilement être compatible 2.0, mais au delà je ne sais pas. Par exemple il existe les fonctions lambda mais pas le mot clés where (oui, je sais je suis plutôt mal partie :/). J'ai posté ici pour savoir ce qu'il est possible de faire en C# et voir si je peux faire la même chose en Vala ou s'il faut implémenter de nouvelles fonctionnalités

[SaumonAgile]

Et ça, ça ne te convient pas :

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
39
40
41
42
class AbstractFactory
    {
 
    }
 
    class Factory<G, H> : AbstractFactory where G : new() 
    {
        private static Factory<G, H> instance;
 
        protected Factory()
        {
        }
 
        public static Factory<G, H> get_instance()
        {
            if (instance == null)
            {
                instance = new Factory<G, H>();
            }
            return instance;
        }
    }
 
    class TreeView
    {
    }
 
    class Project
    {
    }
 
    class ProjectFactory : Factory<TreeView, Project>
    {
    }
 
    class Test
    {
        static void Main(string[] args)
        {
            AbstractFactory factory = ProjectFactory.get_instance();
        }
    }

C'est du C# qui compile.

[ced600]

J'ai abordé ce point dans ma question : factoriser le code de deux factory

Plus concrètement :
D'un côté j'ai une classe ProjectFactory qui hérite des TreeView et qui me permet de gérer les projects d'un IDE
De l'autre une classe DocumentFactory qui est un Notebook et gère les fichiers

Je n'ai pas compris. En plus pourquoi factoriser des factory ? Ce design pattern ne considère t il pas qu'il y a plusieurs factory ? Alors pourquoi les réduire.

Tu es faché avec le mot clés abstract apparement. Il est indispensable d'avoir des classes abstraites pour implémenter correctement ce design pattern.

Une classe abstraite est une classe qui propose des définitions d'arguments et de méthodes. Toutes classes héritant d'une classe abstraite est obligé overrider ces méthodes et arguments. (Sauf ce qui est déclaré comme static.)

Code :

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

1
2
3
4
    public virtual Object create_object()
    {
        return new Object();
    }

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
39
40
41
42
43
 abstract class Factory<G> where G : new()
{
     private static Factory<G> instance;
     public static Factory<G> getFactory() {
         if (instance == null)
        {
            instance = new Factory<G>();
        }
        return instance;
    }
    public abstract MyObject create_object();
 }
 
 
abstract class MyObject ()
{
    public abstract string MaMethode(string MaString);
}
 
class Project : MyObject 
{
   public override string MaMethode(string MaString)
   {
       return "Vous avez passé ce paramètre : " + MaString + " à MaMethode";
   }
}
 
 class ProjectFactory : Factory<Gtk.TreeView>
{
    public override MyObject create_object()
    {
        return new Project();
    }
}
 
 
class Test
{
    static void Main(string[] args)
    {
        ProjectFactory factory = ProjectFactory.getFactory();
    }
}

Un truc dans le genre devrait mieux marcher.

[gege2061]

Je n'ai pas compris. En plus pourquoi factoriser des factory ? Ce design pattern ne considère t il pas qu'il y a plusieurs factory ? Alors pourquoi les réduire.

Peut être parce que je mélange conception et développement

En fait j'utilise le terme factory pour deux choses :

• Le pattern
• Un type de classe qui s'occupe de la gestion d'une autre classe.

Peut être qu'en utilisant le terme Manager pour le second cas, c'est plus clair ?

En gros :

Code :

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

1
2
3
4
5
6
7
8
9
Factory (Pattern)
      |
      |
      V
Manager (classe abstraite générique)
      |
      |
      V
ProjectManager (classe finale) = Manager<Project>

Donc jusque là, c'est plutôt simple. Le problème c'est que mon manager doit en plus hériter d'un widget graphique. Sans héritage multiple le but était de remonter l'héritage au début (donc au niveau du factory) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
widget
      |
      |
      V
Factory (Pattern)
      |
      |
      V
Manager (classe abstraite générique)
      |
      |
      V
ProjectManager (classe finale) = Manager<Project>

Et bien sur comme différent manager peuvent être représenté différemment, ça commence à devenir drôle

Code :

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

1
2
3
4
5
abstract class Factory<G> where G : new()
{
...
            instance = new Factory<G>();
...

Un truc dans le genre devrait mieux marcher.

ça passe en C# ? En vala ce n'est pas possible :

Code x :

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

Can't create instance of abstract class `Factory'

ça me parait plutôt logique.

@SaumonAgile : ça ressemble fort à de l'héritage multiple, non ?

[Skyounet]

Bon moi je viens juste me moquer de gege il est trop tard pour que je puisse comprendre ce que tu essayes de faire

Pis félicitations tu t'essayes enfin à un vrai langage (enfin tu essayes avec ton Vala mais c'est déjà ça ).

Enfin si une question : pourquoi ton manager doit hériter d'un widget graphique ?

C'est super tordu ton truc quand même.

Et on est d'accord que c'est une fabrique abstraite que tu veux faire et pas une fabrique tout court hein ?

[ced600]

abstract fonctionne en C#, j'en ai déjà utilisé.

J'ai l'impression que tu pars sur une mauvaise conception des choses.
Peux tu expliquer ton projet ?

Connais tu les interfaces ? En général on les utilise pour éviter les héritages multiples lorsque que l'on a besoin d'héritages multiples.

mais bon beaucoup te diront que si tu as besoin d'héritage multiple c'est que la conception n'est pas bonne.

Pour le desgin pattern factory :

1. La
2. La factory est une classe qui instancie des Classes.
3. Une factory dérive d'une classe abstraite définnissant sa structure
4. Les classes instanciées dérivent chacune d'une classe abstraite.
5. Le client qui utilise le tout ne connais que les classes abstraites.

Comme le dit Wiki cela permet de séparer la création d'objet de leur utilisation.

Bref le client appelle les méthodes create des factory pour créer ses objets et ainsi récupères les instances de classes.

Il n'aura pas à s'embêter avec le type car tout sera de type la classe abstraite.

Je n'ai jamais trouvé l'intérêt de ce pattern du fait de sa compléxité.
Je préfère utilisé les interfaces et un peu d'héritage à la place.

Et on est d'accord que c'est une fabrique abstraite que tu veux faire et pas une fabrique tout court hein ?

Ta phrase n'as pas de sens car une fabrique dérive d'une classe abstraite.
Peux être il veut une factory générique au lieu de x factory, mais je pense que c'est s'embêter pour rien si c'est le cas. Autant faire une factory qui contient la création de tous les objets.
D'où peut être la confusion avec une classe manager.

[Keihilin]

J'ai conscience que ce que je souhaite faire et un brin tordu, mais je n'ai pas trouvé de solution plus robuste.

elle est tellement robuste qu'elle est inimplémentable

Même si il me semble comprendre où tu veux en venir, j'ai quand même l'impression que tu cherches à faire entrer un pattern à tout prix là où ce n'est pas nécessaire...

A part ça, effectivement, instancier une classe abstraite directement ce n'est pas possible en C# non plus.

cf.

Code :

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

1
2
3
4
5
6
 
abstract class Factory<G> where G : new()
{
...
            instance = new Factory<G>(); // nice try dude ^^
...

[ced600]

A part ça, effectivement, instancier une classe abstraite directement ce n'est pas possible en C# non plus.

cf.

Code :

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

1
2
3
4
5
abstract class Factory<G> where G : new()
{
...
            instance = new Factory<G>(); // nice try dude ^^
...

Heu.... Oui tout a fait, je n'avais pas vu que j'avais écrit cette bétise
En plus j'ai jamais instancié mes classes abstraites !!!!!! Je vous jure des fois je me dit que j'aurais du rester couché !!!!

Bon en faisant des modifs du code de wiki en reprenant le tiens je me suis enmélé les pinceaux

Reprenons :

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 abstract class Factory<G> where G : new()
{
     private static Factory<G> instance;
     public static Factory<G> getFactory() {
         if (instance == null)
        {
            instance = new MyFactory<G>();
        }
        return instance;
    }
    public abstract MyObject create_object();
 }
 
//N'utilisant pas souvent les générique je ne sais pas si Class MyFactory<G> : Factory<G> where G : new() est valable.
//Peut être plutot Class MyFactory<G> : Factory<G>
 
Class MyFactory<G> : Factory<G> where G : new()
{
    public override MyObject create_object()
    {
          return new MyObject();
    }
}
 
 
abstract class MyObject ()
{
    public abstract string MaMethode(string MaString);
}
 
class Project : MyObject 
{
   public override string MaMethode(string MaString)
   {
       return "Vous avez passé ce paramètre : " + MaString + " à MaMethode";
   }
}
 
 class ProjectFactory : Factory<Gtk.TreeView>
{
    public override MyObject create_object()
    {
        return new Project();
    }
}
 
 
class Test
{
    static void Main(string[] args)
    {
        ProjectFactory factory = ProjectFactory.getFactory();
    }
}

[Skyounet]

Ta phrase n'as pas de sens car une fabrique dérive d'une classe abstraite.

Je parle des 2 patterns existants : la fabrique et la fabrique abstraite.
http://fr.wikipedia.org/wiki/Fabriqu..._conception%29
http://fr.wikipedia.org/wiki/Fabriqu..._conception%29
L'un utilise l'autre mais il faut quand même qu'il sache ce qu'il veut faire le ptit gege.

[gege2061]

J'ai l'impression que tu pars sur une mauvaise conception des choses.

Mauvaise je sais pas, tordu c'est certain

Bon je pense que je vais faire simple en ayant une propriété Manager::widget qui sera mon TreeView ou Notebook.

Connais tu les interfaces ? En général on les utilise pour éviter les héritages multiples lorsque que l'on a besoin d'héritages multiples.

Oui mais il n'est pas possible d'implémenter des fonctions dans une interface donc ça me sert à rien ici

mais bon beaucoup te diront que si tu as besoin d'héritage multiple c'est que la conception n'est pas bonne.

Je suis entièrement d'accord, surtout que ce n'est pas possible simplement.

Même si il me semble comprendre où tu veux en venir, j'ai quand même l'impression que tu cherches à faire entrer un pattern à tout prix là où ce n'est pas nécessaire...

Disons que j'avais une bride de pattern que je souhaitai approfondir, comme d'habitude le mieux est de repartir de zéro.

Bon voilà le résultat :

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
using System.Collections.Generic;
 
class Manager<G>
{
    public G widget;
    private static Manager<G> instance;
 
    protected Manager()
    {
    }
 
    public static Manager<G> get_instance()
    {
        if (instance == null)
        {
            instance = new Manager<G>();
        }
        return instance;
    }
 
    public virtual MyObject create_object()
    {
        return new MyObject();
    }
}
 
class MyObject
{
}
 
class Project : MyObject
{
}
 
class TreeView
{
}
 
class ProjectManager : Manager<TreeView>
{
    public override MyObject create_object()
    {
        return new Project();
    }
}
 
class Test
{
    static void Main(string[] args)
    {
        Manager<TreeView> factory = ProjectManager.get_instance();
    }
}

Est ce que c'est plus compréhensible ?

[ced600]

Je parle des 2 patterns existants : la fabrique et la fabrique abstraite.
http://fr.wikipedia.org/wiki/Fabriqu..._conception%29
http://fr.wikipedia.org/wiki/Fabriqu..._conception%29
L'un utilise l'autre mais il faut quand même qu'il sache ce qu'il veut faire le ptit gege.

Bon bah je m'excuse encore de mon erreur, mais en faite je ne connaissais que la fabrique abstraite et je l'avais considéré comme la fabrique


oui un peu plus clair en même temps si tu ne mets pas les fonction en abstract l'utilisateur n'est pas obligé de les overrider.

Pour les interfaces, cela fonctionne un peu comme les classe abstraites, cela oblige toutes classes l'utilisant d'ovverider un certain nombre de méthode.
C'est comme un contrat de confiance qui permet d'être sur que toutes classes implémentant telle IHM possède certaines méthodes bien précise.