Memorystream to byte[]

Version imprimable

07/04/2011, 12h11
asnaeb

Memorystream to byte[]
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:

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
07/04/2011, 12h37
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 ;)
07/04/2011, 12h46
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 ;)
07/04/2011, 14h23
tomlev
Citation:

Envoyé par supermouton

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:

1 2 3 Stream socketStream = new NetworkStream(socket); BinaryFormatter formatterEnvoi = new BinaryFormatter(); formatterEnvoi.Serialize(socketStream, maRequete);
07/04/2011, 14h54
supermouton

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

Bonne après midi ;)
07/04/2011, 15h25
asnaeb

Bonjour tomlev,

pour ta deuxième méthode, comment est-ce que j'envoie mes données alors ?
07/04/2011, 15h41
tomlev

Citation:

Envoyé par asnaeb

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
07/04/2011, 15h58
asnaeb

Ah bon 8-) 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 :?
07/04/2011, 16h03
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
07/04/2011, 16h17
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 :?
07/04/2011, 17h11
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.
08/04/2011, 09h43
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:

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 ?
08/04/2011, 10h11
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
08/04/2011, 10h35
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 ?
08/04/2011, 10h46
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.
08/04/2011, 10h46
tomlev

Citation:

Envoyé par asnaeb

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

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:

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:

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 :

Citation:

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:

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

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

Aurait-tu une idée ?

08/04/2011, 12h00
tomlev

Citation:

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 :

Citation:

<?xml version="1.
08/04/2011, 12h12
asnaeb
Effectivement :oops: Il me semblant que j'avais changé les lignes de codes partout .. Bref j'ai changé en remplaçant par
Code:

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 ?

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

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

08/04/2011, 12h31
asnaeb

Je viens de tester, ça bloque toujours le mobile :? Je ne vois pas comment faire :(
08/04/2011, 13h47
tomlev

Bizarre... et si tu fermes explicitement la socket ?
08/04/2011, 14h08
asnaeb
Après la réception sur le client, j'ai fait :
Code:

1 2 socketC.Shutdown(SocketShutdown.Both); socketC.Close();
Mais toujours le même résultat ...
11/04/2011, 09h01
asnaeb

Tu n'aurais pas une solution ? :?
11/04/2011, 09h45
tomlev

Bah si j'en avais une je te l'aurais donnée...

Quand tu dis "ça bloque le mobile", tu veux dire que ça bloque tout ? Ou juste l'application ? (je précise que je ne connais rien à Windows Mobile...)
11/04/2011, 10h35
asnaeb

Il bloque seulement l'application, à mon avis il reste bloqué sur un receive mais je ne trouve pas où, enfin si vraiment cela ne fonctionne pas, je retournerai à l'envoi de données sous format de tableau de byte.