Probleme bigendian, littleendian

Version imprimable

24/03/2008, 11h17
rgesnot

Probleme bigendian, littleendian

Bonjour,

Je lis un BinaryReader avec des commandes telles que ReadInt16 .

Le BinaryReader est basé sur d'un MemoryStream.

Qui est lui même issu d'un tableau de byte.

Lui même étant un packet TCP capturé.

Mon problème est le suivant.

Je lit 2 bytes dans mon BinaryReader avec la commande ReadInt16

Si je regarde en debug, j'ai en valeur hexadecimal : 00 18 ce qui devrait me donner 24 en décimal (en tout cas c'est ce que j'attends).

Mais j'obtiens 6144 en décimal qui est la valeur décimal de 18 00 (en hexa)

Je voudrais savoir si il y a un moyen simple d'obtenir la bonne valeur.

Je vous remercie par avance.
RG

Bon, je me réponds à moi même, car j'ai trouvé des trucs pas mal.

1) Une bibliotheques qui propose des BnnaryReader/Writer avec indication du type d'"endian"
http://www.yoda.arachsys.com/csharp/miscutil/

(y a aussi d'autres trucs sympa)

2) Et c'est ca que j'ai choisi.

On trouve sur cette page : http://vectordotnet.blogspot.com/200...-of-multi.html

4 méthodes de conversions, elles sont comparées avec graphique (performances) à l'appui

J'ai pas choisi la plus performante, mais la plus simple.

Et voici le résultat pour ce que j'avais besoin :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 private static Int64 endianConverter(Int64 value) { Byte[] bytes = BitConverter.GetBytes(value); Array.Reverse(bytes); return BitConverter.ToInt64(bytes, 0); } private static short endianConverter(short value) { Byte[] bytes = BitConverter.GetBytes(value); Array.Reverse(bytes); return BitConverter.ToInt16(bytes, 0); } private static int endianConverter(int value) { Byte[] bytes = BitConverter.GetBytes(value); Array.Reverse(bytes); return BitConverter.ToInt32(bytes, 0); }

Et en plus performant :

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
 
        public static ulong Reverse(ulong x)
        {
            return
                ((x >> 56) & 0x00000000000000FF) |
                ((x >> 40) & 0x000000000000FF00) |
                ((x >> 24) & 0x0000000000FF0000) |
                ((x >> 8) & 0x00000000FF000000) |
                ((x << 8) & 0x000000FF00000000) |
                ((x << 24) & 0x0000FF0000000000) |
                ((x << 40) & 0x00FF000000000000) |
                ((x << 56) & 0xFF00000000000000);
        }
 
        public static long Reverse(long x)
        {
            ulong ux = (ulong)x;
            return (long)(
                ((ux >> 56) & 0x00000000000000FF) |
                ((ux >> 40) & 0x000000000000FF00) |
                ((ux >> 24) & 0x0000000000FF0000) |
                ((ux >> 8) & 0x00000000FF000000) |
                ((ux << 8) & 0x000000FF00000000) |
                ((ux << 24) & 0x0000FF0000000000) |
                ((ux << 40) & 0x00FF000000000000) |
                ((ux << 56) & 0xFF00000000000000));
        }
 
        public static uint Reverse(uint x)
        {
            return
                ((x >> 24) & 0x000000FF) |
                ((x >> 8) & 0x0000FF00) |
                ((x << 8) & 0x00FF0000) |
                ((x << 24) & 0xFF000000);
        }
 
        public static int Reverse(int x)
        {
            uint ux = (uint)x;
            return (int)(
                ((ux >> 24) & 0x000000FF) |
                ((ux >> 8) & 0x0000FF00) |
                ((ux << 8) & 0x00FF0000) |
                ((ux << 24) & 0xFF000000));
        }
 
        public static ushort Reverse(ushort x)
        {
            return (ushort)(
                ((x >> 8) & 0x00FF) |
                ((x << 8) & 0xFF00));
        }
 
        public static short Reverse(short x)
        {
            ushort ux = (ushort)x;
            return (short)(
                ((ux >> 8) & 0x00FF) |
                ((ux << 8) & 0xFF00));
        }
    }