Discussion :

[koyot3]

Bonjour à tous,

J'ai plusieurs classes static qui utilisent à peu près le même code. J'ai donc essayé de factoriser le code. Mon objectif est d'avoir une classe static à la fin.

En gros il me faudra :

ClassDeBase

void Method
{
blabla
SousMethode
}

virtual void SousMethod()
{
}

static Class1 : ClassDeBase

override void SousMethode()
{
blabla
}

void LanceMethode
{
Method()
}

Bon je ne sais pas si je suis très clair... Je cherche la meilleure optique pour faire ce genre d'héritage, donc si quelqu'un à une idée ! Je m'embrouille avec tous les termes...

Par avance, merci !!

@+

[kheironn]

tu ne peux pas faire une classe static qui hérite d'autre chose que d'Object...

[koyot3]

donc si je veux garder cette arborescence, je ne peux donc pas utiliser une classe static au final.
Je suis obligé de passer par une classe normale et que je devrais instancier dans mon application finale ? C'est bien ça si j'ai bien compris le principe ?

[Er3van]

Une classe statique est implicitement sealed, et donc non dérivable.

Si j'ai bien compris ce que tu veux, une classe (abstraite?) en classe mère et des classes "normales" en filles, qui overrident (néologisme...) ou implémentent des méthodes statiques, répondrait en grande partie à ton besoin.

Pas besoin ainsi d'instancier ta classe fille dans ton application/classe consommatrice si tant est que tu n'utilises que des méthodes statiques.

[koyot3]

J'ai une classe static de base qui contient deux méthodes.
La méthode 1 utilise la méthode 2. Seule cette dernière peut être modifié dans les classes "filles".

Mon but est d'avoir au final une classe static qui redéfinie une méthode 2 et appelle la méthode 1.

Bref, j'espère que cette explication est un peu plus claire...

J'arrive pas à voir comment modéliser ça en fait, en n'ayant au final qu'une classe "fille" static dans mon application !
Je ne peux pas appeler de méthode non statique dans une méthode static de ma classe "fille". C'est la conservation de l'état static qui me pose soucis

[NicoL__]

Pas besoin d'héritage, tu peux juste faire une composition.

Class de base :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void Method
{
blabla
SousMethode
}
 
virtual void SousMethod()
{
}

Class static

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
private final static BaseClass bc = new BaseClass();
 
void SousMethode()
{
      blabla
}
 
void Methode
{
    bc.Method()
}

[Er3van]

Là par contre ça va coincer, je ne vois pas comment tu peux faire un override sur une méthode statique...

Voici une implémentation qui devrait fonctionner (pas testé), mais avec une classe fille non statique.
Si j'ai bien compris ce serait une méthode 3 qui utiliserait la méthode 1 de la classe mère.

Classe mère :

Code c# :

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

1
2
3
4
5
 
public abstract class ClasseMere {
     protected static void Methode1(Object param) { ... this.Methode2(); }
     public virtual void Methode2(Object param) { ... // Jamais appelée a priori }
}

Classe fille :

Code c# :

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

1
2
3
4
5
 
public class ClasseFille : ClasseMere {
     protected override void Methode2(Object param) { ... // appelée par ClasseMere.Methode1 via ClasseFille.Methode3() }
     public static void Methode3(Object param) { ... ClasseMere.Methode1(); }
}

[koyot3]

Merci pour ton exemple j'ai testé de la sorte :

Code de la classe "mère"

Code c# :

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
public class ClassDeBase
{
 
        public void DoWork(object obj)
        {
            Method1();
        }
 
        private void Method1()
        {       
                 //Blabla       
                SousMethode(child);            
        }
 
        public virtual void SousMethode(object child)
        {            
        }

Et pour ma classe "fille"

Code c# :

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
public class ClassFille : ClassDeBase
    {
 
        private static ClassDeBasebc = new ClassDeBase();
 
 
 
        public override void SousMethode(object child)
        {
        //blabla
        }
 
       public static void Run()
        {            
            bc.DoWork(obj);
        }

Ca compile par contre ma méthode SousMethode n'est pas la bonne : il me garde celle de la classe mère

@Er3van : mon objectif est au final d'avoir une classe "fille" appelée en static tel que ClassFille.Run() en gros
Par contre dans ton code, je ne peux pas utiliser le This.Method2() car on part d'une méthode static non ?!

Merci en tout cas

[NicoL__]

Ok c'est un peu plus compliqué en fait faut faire une sorte de visiteur (je me la pète).
Interface

Code :

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

1
2
3
4
5
 
public interface ISousMaMethode
{
     void SousMethode(object child);
}

classe "mère"

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public class ClassDeBase
{
        public void DoWork(ISousMaMethode smm, objet child)
        {
              //Blabla       
                obj.SousMethode(child);   
             //Blabla
        }    
}

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
 
public class ClassFille : ISousMaMethode
    {
 
        private static ClassDeBasebc = new ClassDeBase();
        private static ClassFille current = new ClassFille ();
 
        public void SousMethode(object child)
        {
              //blabla
        }
 
       public static void Run()
        {            
            bc.DoWork(ClassFille.current , obj);
        }

[Nathanael Marchand]

Au lieu de se trimballer des classes statiques, pourquoi ne pas utiliser des singletons?

[NicoL__]

Je réponds à la question : une méthode static avec un fonctionnalité d’héritage.
J'ai des propriétés static pour implémenter une méthode static... de toute façon derrière un singleton y a une propriété static... et là en faisant un new direct je ne me pose pas de question en plus ce sont des membres privés.

[Er3van]

Au lieu de se trimballer des classes statiques, pourquoi ne pas utiliser des singletons?

Quel manque cruel d'originalité ! Si on utilise les bons pattern aux bons endroits c'est même plus drôle après !

Blague à part, oui c'est une solution, par contre, ça impose de gestion une instance de la classe dans la classe consommatrice, plutôt que de faire des appels directement sur la classe.
En soit c'est pas bien méchant, mais comme ce n'est pas ce qu'il voulait...

[koyot3]

Merci NicoL__

ça marche nickel, et merci à tous pour votre aide !!

et pour les singletons, le soucis vient que la classe consommatrice appelait déjà la méthode en static. Mon objectif était de redéfinir mes différents traitements de manière propre en amont sans modifié l'aval...
donc en gros je ne voulais pas modifier la classe consommatrice

[tomlev]

Ca n'a pas de sens de mettre des méthodes virtuelles dans une classe statique (d'ailleurs c'est interdit)... lors de l'appel d'une méthode virtuelle, pour savoir quelle méthode appeler, le CLR se base sur le type de l'instance. Or pour une classe statique, il n'y a pas d'instance...

[stephaneweg]

Utilise les singletons.

Crée ton arboressence de classe, comme tu le ferait avec des classes normales. et les classes dont tu as besoin en statique, implémente le singleton