Discussion :

[JuTs]

Bonjour

J'ai les interfaces suivantes :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
interface IDslr
{
    List<ICamera> CamerasList
    {
        get;
    }
 
//...
}

Code :

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

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 :

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

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

[smyley]

bah ...

Code :

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

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 ...

[JuTs]

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, ...

[Bobbledople]

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?

[Bluedeep]

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

[JuTs]

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.

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

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

[Bobbledople]

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 :

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

1
2
3
4
5
6
7
8
9
10
 
interface IDslr<T> where T : ICamera
{
    List<T> CamerasList
    {
        get;
    }
 
//...
}

Code :

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

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 :

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

1
2
3
 
Dslr<Camera> dslr1 = new Dslr<Camera>();
Dslr<Camera2> dslr1 = new Dslr<Camera2>();

[JuTs]

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

[Bobbledople]

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

[JuTs]

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) ?

[Bobbledople]

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 :

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
 
// 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

[JuTs]

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 :

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

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.

[Bobbledople]

Une classe peut implémenter plusieurs interfaces

Code :

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

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 :

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

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

[JuTs]

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

[Bobbledople]

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

[JuTs]

ç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.

[Bobbledople]

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

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 :

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
 
    // 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

[JuTs]

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


Merci