Discussion :

[vincentweb]

Bonjour,

je souhaiterais définir un opérateur "+" sur la classe Byte pour concaténer des listes de Byte.
Les exemples que l'on trouve dans des cours ne sont faits qu'avec des classes faites maison ou en utilisant les concepts d'héritage.

Certes, une solution bourrin serait de faire une classe Byte2 héritée de Byte, et de définir mon opérateur "+". Mais je devrais refaire mes fonctions Receive, Send, ... pour qu'ils utilisent Byte2 au lieu de Byte...

C'est pour cela qu'il me parait plus futé d'essayer de modifier les classes du framework, si c'est possible. Est_ce possible et comment ?

Merci

[smyley]

Bah ... tu crées ta classes Byte2 et tout et tout
En fait, tu peut t'en sortir en définissant une conversion implicite de Byte2 vers Byte :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public static implicit operator Byte(Byte2 a)
        {
            /* Convertit a en Byte */
        }
 
        public static implicit operator Byte2(Byte a)
        {
            /* Convertit a en Byte2 */
        }

et ainsi, ton code n'aura pas besoin d'être modifié, le compilateur va faire la conversion automatiquement.

[vincentweb]

en faite, l'opérateur +, ce n'est pas pour additionner des variables de type byte, mais pour concaténer des tableaux de type byte (enfin des byte[]).

[smyley]

je pense que ça doit être possible de faire une conversion implicite d'un type Byte2 vers byte[] ... essayes pour voir (je suis trop pressé pour l'instant pour tester moi même )

[vincentweb]

merci, voici ce que cela donne :

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
59
60
61
62
63
64
 
// Main.cs created with MonoDevelop
 
using System;
using essai2;
 
namespace essai2
{
	class Byte2
	{
		public byte[] array;
 
		public Byte2(byte[] b) { array = b; }
 
		public static implicit operator byte[](Byte2 a)
		{
                        return a.array;
		}
 
                 public static implicit operator Byte2(byte[] a)
                 {
                        return new Byte2(a);
                 }
 
		public static void printByte2(Byte2 b)
		{
			foreach(byte a in b.array)
			{
				Console.Out.Write(a);
				Console.Out.Write(" ");
			}
			Console.Out.Write("\n");
		}
 
		private static Byte2 byte_concat(Byte2 a1, Byte2 a2)
                  {
			Byte2 a3 = new byte[a1.array.Length + a2.array.Length];
                        a1.array.CopyTo(a3, 0);
                        a2.array.CopyTo(a3, a1.array.Length);
                        return a3;
                  }
 
		public static Byte2 operator +(Byte2 a1, Byte2 a2) {
		        return byte_concat(a1,a2);
		}
	}
 
	class MainClass
	{
		public static void Main(string[] args)
		{
			byte[] b = new byte[2];
			b[0]=25;
			b[1]=21;
			byte[] b2 = new byte[2];
			b2[0]=26;
			b2[1]=22;
			Byte2 a = new Byte2(b);
			Byte2 a2 = new Byte2(b2);
			Byte2.printByte2(a+a2);
			byte[] b3 = a+a2; //si on veut
		}
	}
}

Résultat :

25 21 26 22

[NoCxDev2]

Hello,

Microsoft, avec .Net 3.0 à introduit les Méthodes d'extensions. Un petit sucre syntaxique à utiliser avec soin car il peux vite rendre le code confus.

Cela permet de déclarer de nouvelles méthodes pour un objet déja existant tel que String. Et d'utiliser cette méthode directement sur l'objet d'origine.

http://msdn.microsoft.com/fr-fr/library/bb311042.aspx

Je pense donc que c'est aussi possible pour la surcharge d'opérateurs, a creuser...

Have fun