Discussion :

[BigNic]

Bonjour,
j'ai une question qui me semble trivial pourtant je n'arrive pas à trouver la réponse.
je développe en C# j'ai des classes A1, A2, A3 etc qui implémentent toutes de IA. J'ai une Factory FA qui sert à instancier ces classes. Or pour que la factory puisse les créer je doit déclarer public les constructeur de ces classes, mais je ne veut pas que c'est classes soient instanciable en dehors de ma factory. Comment faire cela en C# ?

[StormimOn]

Pour réaliser ça, ta factory, ton interface et les classes qui l'implémentent devraient être dans un assembly à part (sous la forme d'une bibliothèque de classe).

Tu rend la factory et l'interface publique. Les classes seront déclarées comme internal (revient à du public mais avec une visibilité uniquement dans l'assembly).

Ainsi de l'extérieur seules la factory et l'interface seront visibles. Les classes ne seront pas visibles.

[Pragmateek]

En faire des classes internes protected à la factory est une solution possible :

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
using System;
 
public interface IA
{
}
 
class IAFactory
{
	protected class A1 : IA
	{
	}
 
	protected class A2 : IA
	{
	}
 
	protected class A3 : IA
	{
	}
 
	public IA New(String s)
	{
		IA result = null;
 
		if (s.Equals("A1"))
		{
			result = new A1();
		}
		else if (s.Equals("A2"))
		{
			result = new A2();
		}
		else if (s.Equals("A3"))
		{
			result = new A3();
		}
 
		return result;
	}
}
 
class Test
{
	static void Main()
	{
		// Factory.A1 a1 = new Factory.A1(); // Won't compile because A1 type is protected
 
		IAFactory f = new IAFactory();
 
		IA a1 = f.New("A1");
		IA a2 = f.New("A2");
		IA a3 = f.New("A3");
 
		Console.WriteLine(a1);
		Console.WriteLine(a2);
		Console.WriteLine(a3);
	}
}

[StormimOn]

Sans moi pour faire ça.

Si tu as 2-3 classes qui se battent en duel et qu'elles n'ont presque rien comme contenu à la rigueur, pour tester.

Mais si tu veux quelque chose de propre, si tu as plus de classes, qu'elles sont plus ou moins consistante, que tu fais un fichier par classe, ... ce n'est plus envisageable. Avis perso bien évidemment.

[Pragmateek]

En effet c'est vrai dans le cas général, mais C# 2.0 permet la définition d'une classe dans plusieurs unités de compilation via les classes partial :

IA.cs :

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
using System;
 
public interface IA
{
}
 
partial class IAFactory
{	
	public IA New(String s)
	{
		IA result = null;
 
		if (s.Equals("A1"))
		{
			result = new A1();
		}
		else if (s.Equals("A2"))
		{
			result = new A2();
		}
		else if (s.Equals("A3"))
		{
			result = new A3();
		}
 
		return result;
	}
}

A1.cs :

Code :

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

1
2
3
4
5
6
partial class IAFactory
{
	protected class A1 : IA
	{
	}
}

A2.cs :

Code :

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

1
2
3
4
5
6
partial class IAFactory
{
	protected class A2 : IA
	{
	}
}

A3.cs :

Code :

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

1
2
3
4
5
6
partial class IAFactory
{
	protected class A3 : IA
	{
	}
}

Test.cs :

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
using System;
 
class Test
{
	static void Main()
	{
		// Factory.A1 a1 = new Factory.A1(); // Won't compile because A1 type is protected
 
		IAFactory f = new IAFactory();
 
		IA a1 = f.New("A1");
		IA a2 = f.New("A2");
		IA a3 = f.New("A3");
 
		Console.WriteLine(a1);
		Console.WriteLine(a2);
		Console.WriteLine(a3);
	}
}

De plus, conceptuellement, un assembly est plus une unité "technique" que "métier" comme une classe.
D'une part cela empêchera la portabilité de la conception à des langages ne supportant pas une approche similaire (Python ? Si quelqu'un pouvait confirmer ou infirmer..., autres ?).
D'autre part si l'on souhaite, pour des raisons techniques, ajouter à la bibliothèque d'autres entités, l'accès aux classes ne sera plus protégé.

[BigNic]

De plus que ajouté un assembly n'est pas sans effet sur le temps de compilation