Discussion :

[Ginetteguy]

Bonjour à tous,

J'ai une petite question concernant les interfaces.

J'ai deux interfaces IFacture et IFactureDetail qui représentent des classes d'entités.

Deux classes implémentent IFacture, Facture et FactureUI, deux autres classes implémentent IFactureDetail, FactureDetail et FactureDetailUI.

Mes classes Facture et FactureUI doivent respectivement posséder des membres de List de leur détail.

Comment faire pour que Facture et FactureUI respectent bien leur contrat d'interface qui contient une List<IFactureDetail> ?

Merci

Axel

[tomlev]

Comment faire pour que Facture et FactureUI respectent bien leur contrat d'interface qui contient une List<IFactureDetail> ?

Bah tu déclares cette propriété dans la classe, comme pour les autres membres d'interface... je comprends pas trop ton problème, il faudrait que tu expliques plus clairement ce qui te gène.

[MaximePalmisano]

Je pense qu'il cherche à s'assurer que les classes qui implémentent son interface implémentent également des membres List.

Je crois pas que ce soit possible avec une interface, il te faudrait une classe mère abstraite implémentant l'interface et la List que tu souhaites. Il faut ensuite faire dériver tes classes de cette classe mère.

[Ginetteguy]

Clairement je souhaite que Facture et FactureUI implémentent IFacture, sans leur passer List<IFacture> mais bel et bien leur liste respective.

Code :

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

1
2
3
4
5
6
public interface IFacture
{
//Membres de l'interface
 
List<IFactureDetail> Detail {get;set;}
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class Facture : IFacture
{
//Membres de la classe
 
 
private List<FactureDetail> _Detail;
public List<FactureDetail> Detail 
{
get{return _Detail;}
set{_Detail = value;}
}
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class FactureUI : IFacture
{
//Membres de la classe
 
 
private List<FactureDetailUI> _Detail;
public List<FactureDetailUI> Detail 
{
get{return _Detail;}
set{_Detail=value;}
}
}

Je suis plus clair?

[Nathanael Marchand]

A moins que tu utilises des génériques, ceci n'est pas possible pour la simple et bonne raison qu'une List<FactureDetail> n'est pas une List<IFactureDetail> (être au sens de l'héritage en poo).

Tu peux donc avec les génériques avoir 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
public interface IFactureDetail
{}
 
public interface IFacture<TDetail> where TDetail : IFactureDetail
{
	List<TDetail> Detail {get;set;}
}
 
public class FactureDetail : IFactureDetail
{}
 
public class Facture : IFacture<FactureDetail>
{
	private List<FactureDetail> _Detail;
	public List<FactureDetail> Detail 
	{
		get{return _Detail;}
		set{_Detail = value;}
	}
}

[SaumonAgile]

A moins que tu utilises des génériques, ceci n'est pas possible pour la simple et bonne raison qu'une List<FactureDetail> n'est pas une List<IFactureDetail> (être au sens de l'héritage en poo).

De mémoire ça devrait être possible avec une implémentation explicite de l'interface, non ?

[tomlev]

De mémoire ça devrait être possible avec une implémentation explicite de l'interface, non ?

A priori c'est la voie à suivre...
http://msdn.microsoft.com/fr-fr/library/ms173157.aspx

Mais dans ce cas précis je ne vois pas trop comment ça va marcher... Tu peux faire un truc comme ça :

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 Facture : IFacture
{
        // Implémentation explicite
        List<IFactureDetail> IFacture.Detail
        {
            get { return _Detail.ToList<IFactureDetail>(); }
            set { _Detail = value.Cast<FactureDetail>().ToList(); }
        }
 
	private List<FactureDetail> _Detail;
	public List<FactureDetail> Detail 
	{
		get{return _Detail;}
		set{_Detail = value;}
	}
}

Mais :
1. c'est pas terrible parce que ça fait une copie de la liste à chaque fois
2. pour le set c'est un peu foireux, parce que rien ne garantit qu'une List<IFactureDetail> ne contient que des FactureDetail. Enfin on peut le supposer, mais ce ne sera pas vérifié statiquement par le compilateur...

La question qui se pose, c'est pourquoi as-tu besoin que Detail soit de type List<FactureDetail> plutôt que List<IFactureDetail> ? C'est un peu plus pratique dans certains cas, mais vu les problèmes que ça pose, je ne suis pas sûr que ça vaille la peine. Tu peux toujours faire un cast vers FactureDetail dans les cas où tu as besoin d'un truc spécifique à FactureDetail qui n'est pas défini dans l'interface.

[Nathanael Marchand]

2. pour le set c'est un peu foireux, parce que rien ne garantit qu'une List<IFactureDetail> ne contient que des FactureDetail. Enfin on peut le supposer, mais ce ne sera pas vérifié statiquement par le compilateur...

.OfType<FactureDetail>() sinon

Mais j'avoue que c'est pas top

[tomlev]

.OfType<FactureDetail>() sinon

Ouais mais ça a pas le même sens...

[Ginetteguy]

Bon du coup je suis parti sur les génériques.

Merci bien

[tomlev]

A vrai dire je ne vois pas en quoi la solution avec les génériques résout quoi que ce soit...

Facture implémente IFacture<FactureDetail>, alors que FactureUI implémente IFacture<FactureDetailUI>. Donc Facture et FactureUI implémentent 2 interfaces différentes, ce qui fait qu'elles n'ont plus rien en commun... Alors que le but au départ était qu'elles implémentent la même interface.

(au fait, j'ai corrigé le code dans mon message un peu plus haut : dans mon exemple Facture implémente IFacture, pas IFacture<FactureDetail>)