Bonjour,
Voici de quoi mettre le cerveau en ébullition (le mien est déjà évaporé dans la ventilation ).
J'ai besoin de manipuler plusieurs types qui représentent chacun une valeur de type string ayant une taille et un format fixe (3 chiffres, 2 lettres, avec ou sans espaces, etc...).
Code 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
47
48
49
50
51
52
53
	public struct CodeNumerique3 : ICodeValeur
	{
		#region Attributs
		private string m_valeur;
 
		#endregion
 
		#region Propriétés
		public string ValeurCode
		{
			get { return m_valeur; }
		}
 
		#endregion
 
		#region Constructeurs
		public CodeNumerique3(string code)
		{
			//----- Validation des paramètres -----
			if (code == null) throw new ArgumentNullException("code");
			//if (code.Length != 3) throw new ArgumentOutOfRangeException("code", code, "Le code doit être composé de 3 chiffres uniquement.");
			if (!System.Text.RegularExpressions.Regex.IsMatch(code, @"\A\d{3}\z", System.Text.RegularExpressions.RegexOptions.Compiled)) throw new ArgumentOutOfRangeException("code", code, "Le code doit être composé de 3 chiffres uniquement.");
			//-----
			m_valeur = code;
		}
 
		#endregion
 
		#region Méthodes
		public override string ToString()
		{
			return m_valeur;
		}
 
		static public bool operator ==(CodeNumerique3 code1, CodeNumerique3 code2)
		{
			return (code1.m_valeur == code2.m_valeur);
		}
		static public bool operator !=(CodeNumerique3 code1, CodeNumerique3 code2)
		{
			return (code1.m_valeur != code2.m_valeur);
		}
		static public implicit operator CodeNumerique3(string code)
		{
			return new CodeNumerique3(code);
		}
		static public implicit operator string(CodeNumerique3 code)
		{
			return code.m_valeur;
		}
 
		#endregion
	}
On imagine sur le même modèle les types Alpha2, Alpha3 où la seule différence se situe sur les taille et format autorisés de la valeur interne.
Le but de ces types est de garantir la validité d'une donnée au cours de son usage (en gros qu'il n'y en ai pas qui fasse n'importe quoi en manipulant des champs string bien définis et qui s'étonne après que les données soient pourries).
J'ai opté pour l'instant pour un type structure mais rien ne s'oppose à la transformation en classe, du moment que ça correspond aux fonctionnalités recherchées.

Se trouvent les problèmes suivants :
  1. L'usage d'une structure permet de garantir que le type se comporte en tant que valeur, mais se pose le problème de la valeur par défaut qui ne répond pas à la contrainte sur la valeur (parce que le constructeur concerné est non surchargeable).
  2. En passant par une classe pour contourner le problème 1 cela fait apparaitre le problème de passage par référence et non par valeur lors d'une affectation/copie. L'usage explicite d'une méthode de type Clone() est inenvisageable compte-tenu des futurs utilisateurs, trop débutants (et laxistes !) pour supporter la bonne gestion de la différence valeur/référence dans le contexte.
  3. Avec une structure il y a beaucoup de "copier/coller" de code (manque d'héritage) entre les différents types qui ne changent que sur la contrainte de valeur. Mais ça encore c'est moindre par rapport au reste.

Quelqu'un a-t-il une idée pour corriger/contourner ces problèmes ?
Ou un autre point de vue à me suggérer sur ce sujet ?