Discussion :

[neptune]

Bonjour!

Difficile de donner un titre précis au problème qui m'occupe. Je pose rapidement le décor: j'ai des objets business et leurs équivalents objets de présentation, des facades, et des web services.

Prenons un cas simple.

- J'ai un objet business File, avec ses propriétés (FileName, FileContent, etc.) et ses méthodes (Copy(), Convert(), etc.).
- J'ai son équivalent présentation FileDTO avec uniquement les propriétés utilisées lors de l'affichage (FileName, FileSize, etc.).
- J'ai une facade avec des opérations de base: GetFile, GetAllFiles, CreateFile, UpdateFile, etc.

La facade manipule les objets business (File) en interne mais ne prend en paramètre ou ne renvoi à la couche présentation que des objets présentation (FileDTO).

Tout ceci fonctionne à merveille et j'agrémente ma facade d'opération spécifique à l'objet concerné.

Je réplique ce schéma pour tous mes objets business et me rend rapidement compte que je duplique pas mal de code (toutes les opérations de base CRUD).

Je décide donc de créer un objet business de base, un objet présentation de base et une façade de base afin de généraliser le tout. Et c'est la que ca coince.

En effet, prenons la méthode GetAll:

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
public abstract class BaseFacade<Entity, DTO>
	where Entity : BusinessEntity
	where DTO : BaseDTO
{
	public List<DTO> GetAll()
	{
		List<DTO> result = new List<DTO>();

		QuerySet<Entity> qs = EntityManager.Instance.ListEntities<Entity>(null, null, null, 0, 0);

		foreach (Entity entity in qs)
		{
			DTO item = (DTO)entity;
			result.Add(item);
		}

		return result;
	}
}

Ne compile pas; normal: DTO ne connait pas d'opération de conversion pour transformer entity en DTO. Hors sur mes objets DTO, je définit:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public static explicit operator FileDTO(File file)
{
	FileDTO item = new FileDTO();
 
             ...
             item.FileContent = file.FileContent;
	item.FileName = file.FileName;
             ...
 
	return item;
}

Mais il n'est pas possible (à ma connaissance) de définir cette méthode de conversion explicite de manière abstraite sur la classe de base.

Connaissez vous un moyen de détourner ce fonctionnement? Evidement, le plus simple serait de créer un méthode abstraite au sein de BaseDTO nommée Convert()... mais en static ca sera impossible!

Merci pour vos retours!
Neptune

[dev01]

Salut.

Bon je doit avouer que je suis à l'ouest aujourd'hui et que j'ai pas tout compris ( et pourtant j'ai schotché pendant 10 mn devant l'écran ).

Le truc qui me viens à l'esprit c'est : Pourquoi pas une classe utilitaire statique avec une méthode surchagé pour chaque type de donnée ?

Ainsi ça donnerait cela :

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
 
public static class ConvertUtilities
{
    public static object Convert(object init)
    {
           if( init is File )
               return ConvertFileToFileDTO(init);
         ./...
    }
 
    private static object ConvertFileToFileDTO(object o)
    {
          File file = (File)o;
          ....
 
 
    }
}
 
public abstract class BaseFacade<Entity, DTO>
	where Entity : BusinessEntity
	where DTO : BaseDTO
{
	public List<DTO> GetAll()
	{
		List<DTO> result = new List<DTO>();
 
		QuerySet<Entity> qs = EntityManager.Instance.ListEntities<Entity>(null, null, null, 0, 0);
 
		foreach (Entity entity in qs)
		{
			DTO item = ConvertUtilities.Convert(entity);			result.Add(item);
		}
 
		return result;
	}
}

[neptune]

Oui, c'est une solution, mais je voulais garder le concept de casting.

Quoi qu'il en soit, je remarque que cette "standardisation" de la facade ne concerne que très peu de cas au sein de mon projet et finalement, je n'y gagnerai pas grand chose.

Je pense que ce post peut tomber aux oubliettes ;-)

Merci quand meme