propriété retournant une liste d'interface

Bonjour

J'ai les interfaces suivantes :

Code:

---

1 2 3 4 5 6 7 8 9 10

interface IDslr { List<ICamera> CamerasList { get; }   //... }

---

Code:

---

1 2 3 4 5

interface ICamera { //... }

---

Ainsi que deux classes (pour le moment) implémentant ces deux interfaces. La classe implémentant ICamera (CameraType1) ne me pose pas de problème, laissons-là de côté.

Celle qui me pose problème est celle-ci :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class Dslr : IDslr { public List<...> CamerasList { get { List<...> list = new List<...>(); //... } } }

---

La propriété CamerasList devrait me retourner une liste d'élément de type Camera (qui implémente ICamera).

Est-ce possible de faire cela ?

Merci d'avance

bah ...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class Dslr : IDslr { public List<ICamera> CamerasList { get { List<ICamera> list = new List<...>(); //... return list; } } }

---

Si dans ton interface tu dit que ça doit renvoyer List<ICamera>, tu es obligé de renvoyer ICamera mais si Camera implémente ICamera, tu peux rajouter des Camera à la liste.
Ou alors tu fais une interface générique mais là ça deviens vite sportif ...

Citation:

---

tu es obligé de renvoyer ICamera mais si Camera implémente ICamera, tu peux rajouter des Camera à la liste.

---

C'est vrai. Mais j'aurais voulu limiter les possibilités. Que la liste de Dslr ne puisse contenir que des Camera, que Dslr2 ne puisse contenir que des Camera2, ...

Citation:

---

Envoyé par JuTs

C'est vrai. Mais j'aurais voulu limiter les possibilités. Que la liste de Dslr ne puisse contenir que des Camera, que Dslr2 ne puisse contenir que des Camera2, ...

---

Dslr, Dslr2 et Camera, Camera2 sont des classe différentes ou des instances de classe?

Ben, passe par des génériques, c'est le plus simple.

Citation:

---

Envoyé par Bobbledople

Dslr, Dslr2 et Camera, Camera2 sont des classe différentes ou des instances de classe?

---

Ce sont des classes différentes

Dslr implémente : IDslr
Dslr2 implémente : IDslr
Camera implémente : ICamera
Camera2 implémente : ICamera

CamerasList de Dslr contient des Camera uniquement.
et CamerasList de Dslr2 contient des Camera2 uniquement.

Citation:

---

Envoyé par Bluedeep

Ben, passe par des génériques, c'est le plus simple.

---

ça : http://msdn.microsoft.com/fr-fr/libr...8VS.80%29.aspx ?

Exactement,

Si le code de Dsrl et Dsrl2 est identique et que tu as fait deux classe suniquement pour présiser que Dsrl prend des Camera et Dsrl2 prend des Camera2 alors tu ferais aussi bien de faire des génériques

Quelque chose comme ca :

Code:

---

1 2 3 4 5 6 7 8 9 10

interface IDslr<T> where T : ICamera { List<T> CamerasList { get; }   //... }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class Dslr<T> : IDslr<T> { public List<T> CamerasList { get { List<T> list = new List<T>(); //... return list; } } }

---

que tu utilises comme ca :

Code:

---

1 2 3

Dslr<Camera> dslr1 = new Dslr<Camera>(); Dslr<Camera2> dslr1 = new Dslr<Camera2>();

---

Non, Dslr <> Dslr2. Tout comme Camera <> Camera2

Un peu plus d'explication sur mon projet :

Il s'agit d'un programme devant pouvoir contrôler un (voire plusieurs) appareils photo

Je pourrais donc avoir une classe DslrCanon, DslrNikon, ... même chose pour Camera

Dans ce cas si chaque DslrX prend un et un seul type de camera tu fais directement ce type de camera dans les <>
Si un DslrX peut prendre n type de camera et que tu veux qu'il accepte uniquement ces n type de camera, tu fait une interface commune pour ces n camera, et tu déclare autant d'interface Camera differente que tu as de groupe de camera (j'espere etre clair). Je ne sais pas s'il existe une autre solution

Citation:

---

Dans ce cas si chaque DslrX prend un et un seul type de camera tu fais directement ce type de camera dans les <>

---

C'est exactement ça. Donc, a priori, pas de problème. Mais je mets quoi dans les <> dans mon interface (IDslr) ?

pareil, il faut que tu fasses autant de IDslrX<> qu'il y a de classe DsrX<>
Et dans les <> tu mets l'interafce commune à toutes les classes CameraX que prend DsrX

Admettons que tu as 4 classes Camera (Camera1, Camera2, Camera3 etCamera4 ) et 2 classes Dslr (Dslr1 et Dslr2)

Disons que Dslr1 accepte Camera1 et Camera2 et Dslr2 accepte Camera3 et Camera4
Tu fais :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// Interfaces Cameras interace ICamera12 { ... } interace ICamera34 { ... }   // Classes Cameras class Camera1 : ICamera12 { ... } class Camera2 : ICamera12 { ... } class Camera3 : ICamera34 { ... } class Camera4 : ICamera34 { ... }   // Interface IDsrls interace IDslr1< ICamera12 > { ... } interace IDslr2< ICamera34 > { ... }   // Classe Dsrls class Dslr1<T> : IDslr1<T> { ... } class Dslr2<T> : IDslr2<T> { ... }

---

Cela dis si les classes Dslrs sont les seules à implémenter les interfaces IDslrs tu peux supprimer ces interfaces et mettre directement ICamera12 et ICamera34 à la place de T

Citation:

---

Cela dis si les classes Dslrs sont les seules à implémenter les interfaces IDslrs tu peux supprimer ces interfaces et mettre directement ICamera12 et ICamera34 à la place de T

---

Les classes Dslr ne sont pas des listes. Par contre elle doivent fournir une méthode qui permet de récupérer une liste

Code:

---

1 2 3 4 5 6

// Classes Cameras class Camera1 : ICamera12 { ... } class Camera2 : ICamera12 { ... } class Camera3 : ICamera34 { ... } class Camera4 : ICamera34 { ... }

---

Je ne suis pas sûr que cela puisse convenir :?. Toutes les classes Camera doivent implémenter les méthodes de mon interface ICamera. Les classes camera contiennent les méthodes permettant d'envoyer des instructions aux appareils (ex : déclenchement de la prise de vue). Les Dslr contiennent des méthodes d'initialisation, ... propre à chaque marque.

Une classe peut implémenter plusieurs interfaces

Code:

---

1 2 3 4 5

class Camera1 : ICamera12, ICamera { ... } class Camera2 : ICamera12, ICamera { ... } class Camera3 : ICamera34, ICamera { ... } class Camera4 : ICamera34, ICamera { ... }

---

ou mieux encore :

Code:

---

1 2 3

interface ICamera12, ICamera { ... } interface ICamera34, ICamera { ... }

---

Si j'ai bien compris les groupes de camera servirai uniquement à limiter le nombre de classes autorisées par les classes Dslr au moment du développement?

Si ca n'est pas le cas il est inutile de faire différentes interfaces, il suffit que chaque classe CameraX implement ICamera et que toutes tes classes DslrX prenne en générique <ICamera>

Ici

Citation:

---

Si j'ai bien compris les groupes de camera servirai uniquement à limiter le nombre de classes autorisées par les classes Dslr au moment du développement?

---

C'est ça. Il serait totalement absurde d'autoriser l'ajout d'un appareil Nikon (dont la classe serait par exemple CameraNikon) dans la liste de la classe DslrCanon

Dans ce cas tu dois pouvoir faire ce que j'ai marqué précédement
De cette facon chaque classe camera appartiendra à un goupe et implementera les méthodes définit par l'interface ICamera

ça ne fonctionne pas. Il est absolument nécessaire que l'implémentation retourne le même type que la définition dans l'interface.

Je crois que je vais laisser tomber mon idée pour le moment.
Ce que je peux faire c'est de vérifier le type lors d'un ajout. Comme ça, s'il ne correspond pas au type attendu je refuse l'ajout.

Le faut-il absoluement dans ton programme où est-ce le compilateur qui ne l'accepte pas? Je ne suis pas sur de bien comprendre ce que tu veux :aie:

En gros s'il faut absoluement (pour toi) que toutes tes classes IDslr renvoient des listes de type Camera il n'y a pas possibilité de limitation.
Par contre tu peux peut-etre faire un truc comme ca :

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

// Interfaces Cameras public interface Camera {}   public interface ICamera12 : Camera{ } public interface ICamera34 : Camera{ }   // Classes Cameras public class Camera1 : ICamera12 { } public class Camera2 : ICamera12 { } public class Camera3 : ICamera34 { } public class Camer4 : ICamera34 {}   // Interface IDsrls public interface IDslr< T > where T : Camera { List<T> ListCam(); void Add(T item); }   // Classe Dsrls public class Dslr1<T> : IDslr<T> where T : ICamera12 { public List<T> ListCam() { return new List<T>(); } public void Add(T item) { } } public class Dslr2<T> : IDslr<T> where T : ICamera34 { public List<T> ListCam() { return new List<T>(); } public void Add(T item) { } }   public class MainClass { public static void Main(string[] args) { IDslr<ICamera12> idslr1 = new Dslr1<ICamera12>(); idslr1.Add(new Camera1()); List<ICamera12> cam = idslr1.ListCam(); } }

---

Ici tu as une seul interface définissant ListCam mais les implementations retourne (et accepte) des types limités

Ok, cette fois-ci j'ai compris. Je ne voyais pas où tu voulais en venir avec tes <T> un peu partout :aie:


Merci :ccool: