générique non assignable?

Version imprimable

23/04/2010, 16h09
giova_fr

générique non assignable?
Sauriez vous m'expliquer pourquoi ceci ne fonctionne pas?
Code:

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:

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.
23/04/2010, 16h36
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:

MaClasse marche = new MaClasse<MonTruc>();
23/04/2010, 16h43
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...

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:

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:

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 :cry::D)
}

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

Code:

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.

Hé !!!! mais c'est bien mieux comme ca :D
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:

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 !