Discussion :

[giova_fr]

Sauriez vous m'expliquer pourquoi ceci ne fonctionne pas?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class MaClasse<T> where T : IMonInterface
{
}
 
class MonTruc : IMonInterface
{
}
 
[...]
Main()
{
MaClasse<IMonInterface> marchepas = new MaClasse<MonTruc>();
}

Ca me dit que MaClasse<MonTruc> ne peut etre casté en MaClasse<IMonInterface>

et pourtant on pourrait tres bien faire ceci :

Code :

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

1
2
3
4
5
 
Main()
{
IMonInterface okok = new MonTruc();
}

Je regrette amérement d'avoir mis la main dans les générique, dire qu'à l'origine c'etait pour éviter du code en double....

Merci d'avance.

[KooKiz]

C'est parce que, même si MonTruc dérive de IMonInterface, MyClass<MonTruc> ne dérive pas de MyClass<IMonInterface>.

Ce n'est pas possible en .NET 3.5 et antérieur, mais ça a été rendu possible en .NET 4. Donc si tu peux migrer vers la nouvelle version tant mieux, sinon il va falloir te débrouiller autrement

Une technique pour contourner cette limitation est de créer une classe non générique MaClasse qui hérite de IMonInterface, et faire hériter MaClasse<T> de MaClasse.

IMonInterface -> MaClasse -> MaClasse<T>

Du coup tu peux faire :

Code :

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

MaClasse marche = new MaClasse<MonTruc>();

[giova_fr]

Mille merci pour ta réponse !

Je vais maintenant essayer de la comprendre

C'est l'aspect "fare hériter MaClasse<T> de MaClasse" qui me bloque.

Je prefere éviter de passer à 4.0, l'appli est déja déployée...

[giova_fr]

J'ai fais comme tu as dis en faisant une classe abstraite pure qui implémente l'interface, et ca me ressort toujours la meme erreur.

Aurais tu un ptit bout de code en exemple à me donner stp?

Pour etre plus complet par rapport à mon cas, mon code serait plutot ceci :

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
 
class MaClasse<T> where T : IMonInterface
{
}
 
interface IProduit : ImonInterface
{
}
 
class Voiture : MaClasse<IProduit>
{
}
 
class MonTruc : IMonInterface
{
}
 
[...]
Main()
{
MaClasse<IMonInterface> marchepas = new Voiture();
}

et ca me dit donc que Voiture ne peut etre converti en MaClasse<IMonInterface> meme si je fais comme tu dis :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
abstract class Mouais : IMonInterface
{
}
 
 
class MaClasse<T> : Mouais where T : IMonInterface
{
}
 
Main()
{
Mouais aie = new Voiture();
}

Je devine que je n'ai rien compris (il me faut des vacances )
}

[KooKiz]

Non je me suis trompé dans mon explication. En fait je pensais à quelque chose du genre :

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
55
    interface IMonInterface
    {
        void UneMethode();
    }
 
    class MonAutreClass : IMonInterface
    {
        public void UneMethode()
        {
        }
    }
 
    class MaClasse
    {
        public IMonInterface Obj
        {
            get;
            set;
        }
 
        public void DoSomething()
        {
            this.Obj.UneMethode();
        }
    }
 
    class MaClass<T> : MaClasse where T : IMonInterface
    {
        public new T Obj
        {
            get
            {
                return (T)base.Obj;
            }
 
            set
            {
                base.Obj = value;
            }
        }
 
        public void UneAutreMethode(T unObjet)
        {
        }
    }
 
    class Test
    {
        void Main()
        {
            MaClasse classe = new MaClass<MonAutreClass>();
 
            classe.DoSomething();
        }
    }

Mais c'est plutôt limité comme solution, ça ne s'adapte pas à tous les scénarios.

[giova_fr]

Hé !!!! mais c'est bien mieux comme ca
tu ne sais pas à quel point tu viens de me rendre service, un peu comme si mon mal de crane s'etait envollé

Bon c'est pas tres propre avec tous ces appels indirectes, mais je conserve la généricité, et peux enfin faire une liste hétérogene de mes classes génériques !!!

Code :

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

1
2
3
4
5
List<MaClasse> mesgeneriques = new List<MaClasse>();
mesgeneriques.Add(new MaClass<MonAutreClassA>());
mesgeneriques.Add(new MaClass<MonAutreClassB>());
mesgeneriques.Add(new MaClass<MonAutreClassC>());
mesgeneriques.Add(new MaClass<MonAutreClassD>());

Je ne vois pas encore ce qui pourrait me limiter, mais heureusement le WE arrive ! d'ici lundi j'aurai compilé toutes ces infos je pense.

C'est génial, encore merci !