ajouter une méthode/opérateur à une classe du Framework

Version imprimable

13/07/2008, 16h13
vincentweb

[Résolu] ajouter une méthode/opérateur à une classe du Framework

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

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

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.

13/07/2008, 19h51
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[]).
13/07/2008, 20h22
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 :aie:)

merci, voici ce que cela donne :

Code:

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 :

Citation:

25 21 26 22

20/07/2008, 18h06
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 :)