Discussion :

[takinelinfo]

Bonjour,

J'ai une petite question au niveau de l'héritage.
J'ai une classe mère BaseGUI

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public abstract class BaseGUI : INotifyPropertyChanged
{
	public event PropertyChangedEventHandler PropertyChanged;
 
 
	public void RaisePropertyChanged(object sender, string elementName)
	{
		if(PropertyChanged!=null)
			PropertyChanged(sender, new PropertyChangedEventArgs(elementName));
	}
}

Je voudrais obliger les classes filles à implémenter deux méthodes.
- FromEntity
- ToEntity

Le problème c'est que les types d'entréés et de sorties dépende de la classe fille.
Du coup je ne sais pas comment déclarer mes méthodes dans BaseGUI

Un exemple

Code C# :

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
 
public class UserGUI : BaseGUI
{
	...
	...
 
	public void FromEntity(UserEntity user){
		...
		...
	}
 
	public UserEntity ToEntity(){
		...
		...
	}
	}
 
	public class SportGUI : BaseGUI
	{
	...
	...
 
	public void FromEntity(SportEntity sport){
		...
		...
	}
 
	public SportEntity ToEntity(){
		...
		...
	}
}
 
public abstract class BaseGUI : INotifyPropertyChanged
{
	public event PropertyChangedEventHandler PropertyChanged;
 
	public void RaisePropertyChanged(object sender, string elementName)
	{
		if(PropertyChanged!=null)
			PropertyChanged(sender, new PropertyChangedEventArgs(elementName));
	}
 
	public abstract void FromEntity(?????);
	public abstract ???? ToEntity();
}

Par avance merci.

[rad_hass]

Est ce que l'héritage ici est le meilleur choix pas sûre...

Y a t il un point commun entre tes classes (E/S) ?
Pour obliger les classes à avoir ces méthodes tu peux mettre des interfaces, ça répondrai à ton besoin ?

Sinon y a aussi la solution générique qui peut être bien ici

[Alikendarfen]

l'approche dépend pas mal du code qui effectue les appels à FromEntity et ToEntity (ce code est-il lui-même dépendant d'une classe particulière)... et du fait qu'il y ait ou pas une classe de base pour tous tes Entity (autre qu'object).

Sinon... tu castes. Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
void FromEntity( BaseEntity e )
{
     if ( e is UserEntity )
     {
          UserEntity ue = (UserEntity)e;
          ...
     }
     else
      ...
}

[Pol63]

classe générique :

Code :

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

1
2
3
4
public class mere<T1, T2> 
{
  public abstract T2 mth1(T1 param1);  
}

méthode générique :

Code :

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

1
2
3
4
public class mere 
{
  public abstract void mth<T>(T param1);  
}

[Alikendarfen]

... je crois que je vais demander à google !

A mon sens, utiliser des génériques (quelle que soit la forme) va nécessiter autant de cas distincts pour le code qui appelle ses méthodes (from et to entity) : c'est pas forcément le but

[Pol63]

pour les méthodes génériques, il n'y a rien à faire ca récupère ce qu'on passe
pour les classes par contre il faut rajouter <un type> à chaque nommage de la classe ...

[Alikendarfen]

Je comprends bien ça, mais si l'appel de méthode ne comporte pas de variable du type souhaité (cas où l'appel utilise une classe de base) ça ne marche pas, il me semble (à moins de caster, mais lors de l'appel, cette fois).

[takinelinfo]

Je n'en ai peut être pas suffisament dit tout à l'heure.
C'est une application WPF multi couche (GUI/BLL/DAL/...)
J'ai mes entités qui sont dans un projet référencé dans toutes les couches. Je les suffixe par "Entity" (ex: UserEntity).
Dans ma couche GUI (Projet WPF), je transforme ces entités en entités GUI pour implémenter le support de INotifyPropertyChanged et de ObservableCollection
Voici ce que ça donne niveau code

Code c# :

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
 
public class UserEntity
{
	public long Id { get; set; }
	public string Lastname { get; set; }
	public string Firstname { get; set; }
}
 
public class UserGUI : BaseGUI
{
	private long _Id;
	public long Id
	{
		get { return _Id; }
		set { _Id = value; RaisePropertyChanged(this, "Id"); }
	}
 
	private string _Lastname;
	public string Lastname
	{
		get { return _Lastname; }
		set { _Lastname = value; RaisePropertyChanged(this, "Lastname"); }
	}
 
	private string _Firstname;
	public string Firstname
	{
		get { return _Firstname; }
		set { _Firstname = value; RaisePropertyChanged(this, "Firstname"); }
	}
 
	public UserGUI()
	{
	}
 
	public UserGUI(UserEntity entity)
	{
		FromEntity(entity);
	}
 
	public void FromEntity(UserEntity entity)
	{
		Id = entity.Id;
		Lastname = entity.Lastname;
		Firstname = entity.Firstname;
	}
 
	public UserEntity FromEntity()
	{
		return new UserEntity(){
						Id = Id,
						Lastname = Lastname,
						Firstname = Firstname};
	}
}

En fait j'hérite de BaseGUI pour ne pas avoir à reécrire la méthode RaisePropertyChanged à chaque fois.
Mais je voudrais obliger mes entités GUI à définir la méthode FromEntity et ToEntity.
Hors j'ai un problème pour la signature de la méthode (si je passe par une interface), car le type dépend de la classe fille.