Discussion :

[Franckintosh]

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 ?

[dotEden]

[*]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.

Bonsoir,

Alors là je ne comprend vraiment pas le problème si tu créais une propriété get je ne vois pas en quoi tu fais un passage par référence .

Code :

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

1
2
3
MonObjet o1 = new Objet();
MonObjet o2 = o1; //passage par référence

Code :

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

1
2
3
4
string s;
ObjetString os = new ObjetString();
s = os.maProprieteString; //passage par valeur

Et l'utilisation de .clone() est encore moins compréhensible .
Je pense ne pas du tout avoir compris ton problème en somme.

Cordialement

[Franckintosh]

Code :

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

1
2
3
MonObjet o1 = new Objet();
MonObjet o2 = o1; //passage par référence

Je faisais justement référence (sans mauvais jeu de mot ) à ce cas là, si je récupère mon ObjetString depuis une source pour le copier dans une autre variable du même type.
Le problème n'est pas de récupérer la valeur string, le problème est l'affectation d'un ObjetString dans un autre ObjetString sans copier les références (opérateur = non surchargeable).

[dotEden]

Bonjour,

Dans ton cas, conserve donc l'utilisation de ta structure et tu lui mets un constructeur dans ce cas, l'affectation se fera alors par valeur.

Cordialement

[Franckintosh]

Oui, mais alors juste avec ça se pose le problème n°1...

[Bluedeep]

Je ne comprends pas les problèmes que tu rencontres avec l'usage d'une classe. (d'ailleurs une string est une classe ...)

Par ailleurs, il n'y a pas vraiment de relation entre un type référence et un type valeur d'une part et entre le passage par référence ou par valeur.

Ce sont deux notions assez disjointes.

Bref, je ne vois rien dans ta description qui pose problème.

Et pour l'affectation des valeurs, pourquoi ne fais tu pas une surcharge de l'opérateur d'affectation ?

Exemple :

Code :

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

1
2
3
4
5
 
   public static implicit operator CodeNumerique3(string val)
        {
            return new CodeNumerique3(val);
        }