Envoyer un objet avec un socket

Version imprimable

Bonjour,

Dans le cadre de mon programme, j'aimerais envoyer un objet par un socket. Mais pas uniquement une class.

Le but, c'est d'envoyer ceci :
INT32 : Code de l'objet
INT32 : Taille de l'objet
object : L'objet en lui-même

Comment puis-je faire ça ?
Je crois comprendre que mon erreur provient de l'envoi. Je dois avouer que je ne comprends pas tout à fait comment fonctionne les MemoryStream et les BinaryFormatter.

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
static public class ProtocolMech
{
    static public ProtocolMessage GetMessage(Socket Src)
    {
        Int32 size;
        Int32 type;
        byte[] msg;
        if (Src.Available > 2 * sizeof(Int32))
        {
            msg = new byte[sizeof(Int32)];
            Src.Receive(msg, sizeof(Int32), SocketFlags.None);
            type = (Int32)BitConverter.ToUInt32(msg, 0);
 
            msg = new byte[sizeof(Int32)];
            Src.Receive(msg, sizeof(Int32), SocketFlags.None);
            size = (Int32)BitConverter.ToUInt32(msg, 0);
 
            msg = new byte[size];
            Src.Receive(msg, size, SocketFlags.None);
 
            return new ProtocolMessage(type, ByteArrayToObject(msg));
        }
        else
            return null;
    }
 
 
    static public void SendMessage(Int32 Code, object Obj, Socket Dest)
    {
 
        MemoryStream _MemoryStream = new MemoryStream();
        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter _BinaryFormatter
                    = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
 
        byte[] objbuff = ObjectToByteArray(Obj);
        Int32 SizeOfObj = Convert.ToInt32(objbuff.Length);
 
        _BinaryFormatter.Serialize(_MemoryStream, Code);
        _BinaryFormatter.Serialize(_MemoryStream, SizeOfObj);
        _BinaryFormatter.Serialize(_MemoryStream, Obj);
 
        Dest.Send(_MemoryStream.ToArray(), SocketFlags.None);
    }
 
    static public object ByteArrayToObject(byte[] _ByteArray)
    {
        try
        {
            MemoryStream _MemoryStream = new MemoryStream(_ByteArray);
 
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter _BinaryFormatter
                        = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            _MemoryStream.Position = 0;
 
            return _BinaryFormatter.Deserialize(_MemoryStream);
        }
        catch (Exception _Exception)
        {
            // Error
            throw (_Exception);
        }
    }
 
    static public byte[] ObjectToByteArray(object Obj)
    {
        try
        {
            MemoryStream _MemoryStream = new MemoryStream();
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter _BinaryFormatter
                        = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            _BinaryFormatter.Serialize(_MemoryStream, Obj);
            return _MemoryStream.ToArray();
        }
        catch (Exception _Exception)
        {
            // Error
            throw (_Exception);
        }
    }
}

Merci d'avance.

21/05/2011, 16h50
Nathanael Marchand

Y'a t il un interet quelconque à utiliser les Sockets plutot qu'une couche de plus haut niveau (WCF) ?
21/05/2011, 17h24
MAX-k

Citation:

Envoyé par Nathanael Marchand

Y'a t il un interet quelconque à utiliser les Sockets plutot qu'une couche de plus haut niveau (WCF) ?

Ouaip : Je ne connais rien en WCF.

Et j'ai pigé comment marche le memory stream et le binary formatter. Ce problème est réglé... Maintenant, j'en ai un autre. Je n'arrive pas à caster mon objet désérialisé.

Avec la nouvelle version de mon code, ça marche mieux. Tout est transmis. Le problème vient de la deserialisation.

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
static public class ProtocolMech
{
    static public ProtocolMessage GetMessage(Socket Src)
    {
        Int32 size;
        Int32 type;
        byte[] msg;
        if (Src.Available > 2 * sizeof(Int32))
        {
            Console.WriteLine(Src.Available);
            msg = new byte[54];
            Src.Receive(msg, 54, SocketFlags.None); //54 = nombre de byte du int32
            type = (Int32)ByteArrayToObject(msg);
            Console.WriteLine("Av left : " + Src.Available);
 
 
            msg = new byte[54];
            Src.Receive(msg, 54, SocketFlags.None);
            size = (Int32)ByteArrayToObject(msg);
            Console.WriteLine("Av left 2 : " + Src.Available);
 
            msg = new byte[size];
            Src.Receive(msg, size, SocketFlags.None);
            Console.WriteLine("Av left final : " + Src.Available);
 
            return new ProtocolMessage(type, msg);
        }
        else
            return null;
    }
 
 
    static public void SendMessage(Int32 Code, object Obj, Socket Dest)
    {
 
        MemoryStream _MemoryStream = new MemoryStream();
        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter _BinaryFormatter
                    = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
 
        byte[] objbuff = ObjectToByteArray(Obj);
        byte[] sizebuff = ObjectToByteArray((Int32)objbuff.Length);
        byte[] codebuff = ObjectToByteArray(Code);
 
        byte[] buffTotal = new byte[objbuff.Length + sizebuff.Length + codebuff.Length];
        Buffer.BlockCopy(codebuff, 0, buffTotal, 0, codebuff.Length);
        Buffer.BlockCopy(sizebuff, 0, buffTotal, codebuff.Length, sizebuff.Length);
        Buffer.BlockCopy(codebuff, 0, buffTotal, codebuff.Length + sizebuff.Length, codebuff.Length);
        Dest.Send(buffTotal, SocketFlags.None);
    }
 
    static public object ByteArrayToObject(byte[] _ByteArray)
    {
        try
        {
            MemoryStream _MemoryStream = new MemoryStream(_ByteArray);
 
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter _BinaryFormatter
                        = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            _MemoryStream.Position = 0;
 
            return _BinaryFormatter.Deserialize(_MemoryStream);
        }
        catch (Exception _Exception)
        {
            // Error
            throw (_Exception);
        }
    }
 
    static public byte[] ObjectToByteArray(object Obj)
    {
        try
        {
            MemoryStream _MemoryStream = new MemoryStream();
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter _BinaryFormatter
                        = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            _BinaryFormatter.Serialize(_MemoryStream, Obj);
            return _MemoryStream.ToArray();
        }
        catch (Exception _Exception)
        {
            // Error
            throw (_Exception);
        }
    }
}
 
public class ProtocolMessage
{
    public int Code {set; get;}
    public byte[] Object{get; set;}
 
    public ProtocolMessage(int Code, byte[] Obj)
    {
        this.Code = Code;
        this.Object = Obj;
    }
}

Quand j'invoque ma fonction de deserialisation comme ci :

Code:

Auth = (AuthContent)Protocol.ProtocolMech.ByteArrayToObject(msg.Object);

Il me sort :

Citation:

Impossible d'effectuer un cast d'un objet de type 'System.Int32' en type 'DataType.AuthContent'.

D'où est-ce que ça peut venir ? Je vérifier en debug : Il a bien les bonnes valeurs dans le MS.

24/05/2011, 18h09
NicoL__

J'ai hésité à répondre à ce message... je réitère le conseil de Nathanael. Ou bien code en C ça évitera qu'on te donne ce genre de conseil. Mais sinon ça peut évidement fonctionner, mais j'avoue ne pas avoir eu le courage de décrypter tout ton code.
Un indice, quand tu serialise un objet (une référence) tu sérialises par uniquement le contenu de l'objet mais son "pointeur aussi" la preuve un int32 prend 54 bytes donc il faut partager les définitions de tes classes du serveur au client.
En suite l'objet AuthContent je ne le vois jamais instancier... donc c'est pas ça que tu envoies.
C quoi l'erreur détaillée ?
24/05/2011, 22h27
Pol63

pourquoi utiliser wcf qui permet de transférer des instances de classes quand on peut tout coder soi même avec une classe de bas niveau :D