Discussion :

[asnaeb]

Bonjour,

Voila je ne trouve pas comment il faut faire pour convertir un memorystream en bytes. J'en ai besoin pour faire passer un objet sérialisé dans une socket.

Voici un morceau de code :

Code :

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

1
2
3
MemoryStream memEnvoi = new MemoryStream();
BinaryFormatter formatterEnvoi = new BinaryFormatter();
formatterEnvoi.Serialize(memStream, maRequete);

Ici je sérialise mon objet "maRequete", et je voudrais le faire passer dans ma socket mais il faut que je le convertisse en byte. Comment est-ce que je peux faire ?

Merci d'avance,

Julien

[supermouton]

Bonjour asnaeb,

JE ne sais pas si c'est exactement ce que tu recherche, mais la méthode GetBuffer() d'un MemoryStream retourne le tableau de byte représentant ce flux.

Bonne journée

[asnaeb]

Bonjour supermouton

Merci pour ta réponse, je suppose que c'est ce que je recherche vu que j'ai besoin d'un d'un tableau de byte Je vais essayer cette méthode et je te dis quoi

[tomlev]

JE ne sais pas si c'est exactement ce que tu recherche, mais la méthode GetBuffer() d'un MemoryStream retourne le tableau de byte représentant ce flux.

Attention, ce n'est pas GetBuffer() mais ToArray() qu'il faut utiliser !
GetBuffer() renvoie le buffer tel quel, y compris l'espace réservé par le MemoryStream mais pas utilisé

Sinon, il y a plus simple : plutôt que de sérialiser dans un MemoryStream et de transmettre les bytes, tu peux sérialiser directement sur un NetworkStream sur la Socket :

Code :

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

1
2
3
Stream socketStream = new NetworkStream(socket);
BinaryFormatter formatterEnvoi = new BinaryFormatter();
formatterEnvoi.Serialize(socketStream, maRequete);

[supermouton]

D'accord, merci TomLev pour cette précision. on en apprend tous les jours

Bonne après midi

[asnaeb]

Bonjour tomlev,

pour ta deuxième méthode, comment est-ce que j'envoie mes données alors ?

[tomlev]

pour ta deuxième méthode, comment est-ce que j'envoie mes données alors ?

Le code que je t'ai donné le fait déjà... Le BinaryFormatter sérialise directement sur le flux de la Socket

[asnaeb]

Ah bon J'ai même pas besoin d'appeler la méthode beginSend alors Je vais tester ça de suite.

Je ne comprend pas vraiment comment je dois faire pour récupérer mon objet de l'autre coté, je dois aussi créer un flux networkstream, mais je ne vois pas vraiment comment implémenter

[tomlev]

Bah du côté qui reçoit, tu crées un NetworkStream sur le Socket, et tu désérialises à partir du Stream (avec un BinaryFormatter)

Soit dit en passant, ce serait plus simple en utilisant TcpClient, qui fournit une méthode GetStream

[asnaeb]

Merci Je vais tester ça et je te tiens au courant. Par contre je suis pas trop chaud pour tout changer en TCPClient vu que je vois pas vraiment comment ça fonctionne et si ça correspond au type de serveur que je veux avoir

[tomlev]

Bah en gros un TcpClient c'est un wrapper pour Socket, c'est plus facile à utiliser... mais évidemment ça ne marche qu'en TCP.

[asnaeb]

Merci pour la précision J'ai encore un souci avec mon client maintenant. J'avais oublié de préciser que mon client était un mobile et il ne trouve pas la classe "BinaryFormatter", car il ne trouve pas l'include :

Code :

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

using System.Runtime.Serialization.Formatters.Binary;

Y aurait-il un équivalent avec le framework mobile ? Ou n'est-ce pas possible de sérialiser un objet sous le framework mobile ?

[tomlev]

BinaryFormatter n'est pas supporté par le Compact Framework... Il faut que tu t'orientes vers un autre mécanisme de sérialisation

A priori tu peux utiliser la sérialisation XML, mais c'est assez différent de la sérialisation binaire, et c'est une représentation beaucoup moins compacte (pour un tuto, suis le lien dans ma signature)

Sinon il y a aussi protobuf-net, une implémentation .NET de Protocol Buffers, un format de sérialisation développé par Google. J'ai jamais essayé mais c'est apparemment assez populaire

[asnaeb]

Dommage qu'il ne le supporte pas .. Sinon j'ai parcouru les parties de ton tuto qui m'intéressait et je me demandais s'il était aussi possible de faire passer l'objet sérialisé par le networkstream également ? Ou s'il faut repasser par les méthodes beginSend en transformant l'objet sérialisé en tableau de bytes ?

[asnaeb]

J'ai rien dit Je n'avais pas lu qu'on pouvait passer un networkstream à la méthode Serialize de XMLSerializer. Je vais tester cette méthode et je posterai la résultat.

[tomlev]

Sinon j'ai parcouru les parties de ton tuto qui m'intéressait et je me demandais s'il était aussi possible de faire passer l'objet sérialisé par le networkstream également ?

Oui, selon le même principe... tu sérialises vers le NetworkStream, et de l'autre côté tu désérialises à partir du NetworkStream

[asnaeb]

Okok.

J'ai testé mais, il y a une exception et je ne comprend pas vraiment ce qu'il me veut ... Je poste mon code, c'est peut-être plus simple :

Code serveur :

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
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
class ServeurReseauAsyncObject
    {
 
        #region variables globales
 
        public static byte[] buf = new byte[1024];
        public static AutoResetEvent serveurArrete = new AutoResetEvent(false);
        public static IPAddress adresseServeur;
        public static int port;
        public static FormGAPScanServer parent;
 
        public static String protocole;
        public static Socket socketEc;
 
        //public static RequeteGAP maRequete;
 
        //public Socket socketEc;
 
        #endregion
 
        [STAThread]
        public static void main()
        {
            try
            {
                socketEc = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                socketEc.Bind(new IPEndPoint(adresseServeur, port));
                socketEc.Listen(100);
                IAsyncResult ar = socketEc.BeginAccept(new AsyncCallback(AcceptRealise), socketEc);
 
                ar.AsyncWaitHandle.WaitOne();
 
                serveurArrete.WaitOne();
            }
            catch (SocketException ex)
            {
                MessageBox.Show("Vérifier que vous êtes connecté à un réseau sans fil !", "Avertissement", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
 
        }
 
        static void AcceptRealise(IAsyncResult ar)
        {
            Socket socketC = (Socket)ar.AsyncState;
            Socket sockC = socketC.EndAccept(ar);
            //nouveau 
            IAsyncResult ar2 = socketEc.BeginAccept(new AsyncCallback(AcceptRealise), socketEc);
 
            IPEndPoint ep = (IPEndPoint)sockC.RemoteEndPoint;
 
            Boolean fin = false;
 
            try
            {
 
                while (!fin)
                {
 
                    Stream nStream = new NetworkStream(sockC);
                    BinaryFormatter formatterReception = new BinaryFormatter();
                    RequeteGAP maRequete2 = (RequeteGAP)formatterReception.Deserialize(nStream);
 
 
                    if (maRequete2.ProtocoleGAP == ProtocolGAP.QUITTER)
                        fin = true;
 
                }
            }
            catch (SocketException ex)
            {
                MessageBox.Show("Perte de connexion hôte.", "Avertissement", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
 
            }
 
 
            //parent.ecritureAffichage("Fin client.", "TCP");
 
            sockC.Shutdown(SocketShutdown.Both);
            sockC.Close();
 
            //serveurArrete.Set();
        }
 
        static void ReceptionRealisee(IAsyncResult ar)
        {
            List<String> msgServeur = new List<string>();
 
            Socket socketServ = (Socket)ar.AsyncState;
 
            int n = socketServ.EndReceive(ar);
 
            Stream nStream = new NetworkStream(socketServ);
 
            XmlSerializer xs = new XmlSerializer(typeof(RequeteGAP));
            RequeteGAP maRequete = xs.Deserialize(nStream) as RequeteGAP;
 
 
            int protocole = maRequete.ProtocoleGAP;
 
            if (protocole == ProtocolGAP.RECHERCHEARTICLE)
            {
                String idArticle = maRequete.ListeElement[0];
 
                try
                {
 
                    if (ConfigurationManager.AppSettings["cheminBDMercator"] == null)
                        throw new ExceptionPropertiesNotFound("Fichier de properties non disponible !");
                    else
                    {
                        String cheminMercator = ConfigurationManager.AppSettings["cheminBDMercator"];
 
                        ManipulationDBMercator manip = new ManipulationDBMercator(cheminMercator);
 
                        String responseRequete = manip.getStockDispoViaIDArticle(idArticle);
 
                        if (responseRequete == null)
                        {
                            //msgServeur = "null";
                            msgServeur.Add("null");
                        }
                        else
                        {
                            //msgServeur = responseRequete;
                            msgServeur.Add(responseRequete);
                        }
                    }
                }
                catch (ExceptionPropertiesNotFound ex)
                {
 
                }
            }
 
            #region Protocole GETALLFOURNISSEUR
 
            if (protocole == ProtocolGAP.GETALLFOURNISSEUR)
            {
                if (ConfigurationManager.AppSettings["cheminBDMercator"] == null)
                    throw new ExceptionPropertiesNotFound("Fichier de properties non disponible !");
                else
                {
                    String cheminMercator = ConfigurationManager.AppSettings["cheminBDMercator"];
 
                    ManipulationDBMercator manip = new ManipulationDBMercator(cheminMercator);
 
                    List<String> allFournisseur = manip.getAllFournisseur();
 
                    msgServeur = allFournisseur;
 
 
                }
            }
            #endregion
 
            maRequete.ListeElement = msgServeur;
 
            Stream socketStream = new NetworkStream(socketServ);
 
            XmlSerializer xs2 = new XmlSerializer(typeof(RequeteGAP));
            xs2.Serialize(socketStream, maRequete);
 
        }
 
        static void EnvoiRealise(IAsyncResult ar)
        {
            Socket socketServ = (Socket)ar.AsyncState;
 
            int n = socketServ.EndSend(ar);
        }
    }

Le code client :

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
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
public class ClientAsyncTCPObject
    {
        #region variables globales
 
        private Socket socketC;
        private FormGAP parent;
 
        #endregion
 
        #region constructeur
 
        public ClientAsyncTCPObject(FormGAP _parent)
        {
            this.parent = _parent;
        }
 
        #endregion
 
        public void connection()
        {
            socketC = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 
            IPAddress adresseServeur = IPAddress.Parse("169.254.221.190");
 
            try
            {
                IAsyncResult ar = socketC.BeginConnect(new IPEndPoint(adresseServeur, 8001), new AsyncCallback(ConnexionRealisee), socketC);
                this.parent.IsConnected = true;
 
                socketC.EndConnect(ar);
            }
            catch (Exception ex)
            {
                MessageBox.Show("La connexion a échouée !", "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
                this.parent.IsConnected = false;
            }
        }
 
        public void ConnexionRealisee(IAsyncResult ar)
        {
            Socket sock = (Socket)ar.AsyncState;
        }
 
        public void EnvoyerRequete(RequeteGAP requete)
        {
            try
            {
                Stream streamSocket = new NetworkStream(socketC);
                XmlSerializer xs = new XmlSerializer(typeof(RequeteGAP));
 
                xs.Serialize(streamSocket,requete);
            }
            catch (SocketException ex)
            {
                MessageBox.Show("Erreur de connexion !", "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
            }
        }
 
        public RequeteGAP ReceptionRequete()
        {
            byte[] buf = new byte[1024];
            Boolean isComplete = false;
            String msgServeur="";
 
            try
            {
 
                Stream streamSocket = new NetworkStream(socketC);
                XmlSerializer xs = new XmlSerializer(typeof(RequeteGAP));
                RequeteGAP maReponse = xs.Deserialize(streamSocket) as RequeteGAP;
 
                if (maReponse.ProtocoleGAP == ProtocolGAP.QUITTER)
                {
                    socketC.Shutdown(SocketShutdown.Both);
                    socketC.Close();
                }
 
                return maReponse;
 
            }
            catch (SocketException ex)
            {
                MessageBox.Show("Erreur de connexion !", "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
                return null;
            }
        }
 
        public void EnvoiRealise(IAsyncResult ar)
        {
 
        }
 
        public void ReceptionRealisee(IAsyncResult ar)
        {
 
        }
    }

Lorsque j'envoie un objet à partir du client, il me lance cette erreur :

Le flux d'entrée n'est pas un format binaire valide. Le contenu initial (en octets) est : 3C-3F-78-6D-6C-20-76-65-72-73-69-6F-6E-3D-22-31-2E ...

à la ligne :

Code :

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

RequeteGAP maRequete2 = (RequeteGAP)formatterReception.Deserialize(nStream);

Dans la méthode "AcceptRealise" du code serveur donc à la ligne 61.

Aurait-tu une idée ?

[tomlev]

Le flux d'entrée n'est pas un format binaire valide. Le contenu initial (en octets) est : 3C-3F-78-6D-6C-20-76-65-72-73-69-6F-6E-3D-22-31-2E ...

Bah oui, tu essaies de désérialiser du XML avec un BinaryFormatter...

Le contenu binaire qu'il affiche dans l'errreur correspond au texte suivant :

<?xml version="1.

[asnaeb]

Effectivement Il me semblant que j'avais changé les lignes de codes partout .. Bref j'ai changé en remplaçant par

Code :

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

1
2
3
4
 
Stream nStream = new NetworkStream(sockC);
XmlSerializer xs = new XmlSerializer(typeof(RequeteGAP));
RequeteGAP maRequete2 = xs.Deserialize(nStream) as RequeteGAP;

Mais lorsque j'envoie mon objet, mon mobile reste bloqué. Ne serait-ce pas une histoire de beginreceive, endreceive, etc qui ne sont pas effectué en utilisant le flux réseau ?

[tomlev]

Ferme le flux quand tu as terminé. Le plus simple est de l'utiliser dans un bloc using :

Code :

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

1
2
3
4
5
using (Stream nStream = new NetworkStream(sockC))
{
    XmlSerializer xs = new XmlSerializer(typeof(RequeteGAP));
    RequeteGAP maRequete2 = xs.Deserialize(nStream) as RequeteGAP;
}

Ce sera automatiquement fermé à la fin du using