[C#] Utilisation de NetworkStream

Version imprimable

06/06/2006, 14h21
LE NEINDRE

[C#] Utilisation de NetworkStream

Bonjour,

Je voudrais avoir quelques infos sur le .NET remoting.
J'ai cru comprendre qu'il était possible de passer des objets à d'un client vers un serveur à l'aide de cette "technologie".
Je voudrais donc savoir s'il est possible de passer un tableau de bytes qui contient tous les octets qui composent une photo.

Le but étant d'uploader une image sur un serveur par cette méthode.

Merci pour vos réponses !!!
06/06/2006, 15h15
dev01

Salut .

dans ton cas, une socket fera ce que tu veux et de manière bcp plus simple .

Le remoting permet l'invocation d'objet à distance de la même manière que s'ils étaient locals c'est tout.

Merci pour ta réponse dev01.

J'ai utilisé, en attendant, la classe tcpclient() pour envoyer les fichiers.
ça fonctionne mais c'est long. Peut-être que cette lenteur provient du fait que j'envoie un seul octet à chaque fois.
J'ai fais ceci:
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
 
        private void button2_Click(object sender, EventArgs e)
        {
            DialogResult dial = openFileDialog1.ShowDialog();
            if (dial == DialogResult.OK)
            {
 
                byte[] MyBytes;
                MyBytes = FileToBytes(openFileDialog1.FileName);
                for(int i=0;i<MyBytes.Length;i++)
                {
                    Send(MyBytes[i]);
 
                }
                stw.Close();
                MessageBox.Show("File uploaded !!!");
            }
 
        }
 
        public byte[] FileToBytes(string CheminFichier)
        {
            System.IO.FileInfo MonFichier = new System.IO.FileInfo(CheminFichier);
            System.IO.FileStream MonFileStream = MonFichier.OpenRead();
            byte[] TableauDeBytes = new byte[MonFileStream.Length];
            MonFileStream.Read(TableauDeBytes, 0, (int)MonFileStream.Length);
            MonFileStream.Close();
            return TableauDeBytes;
        }
 
        private void Send(byte block)
        {
            stw.Write(block);
            //new Thread(new ThreadStart(WaitResponse)).Start();
        }

et la partie 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
 
        public void Run()
        {
 
            this.str = new BinaryReader(LiaisionClient.GetStream());
            this.stw = new BinaryWriter(LiaisionClient.GetStream());
            fs = File.Open("d:\\file", FileMode.Create);
            while (!End)
            {
                //Lecture
                try
                {
                    demande = str.ReadByte();
                    fs.WriteByte(demande);
                    //Traitement
                    reponse++;
                    MyBytes.Add(demande);
                    //Ecriture
                    stw.Flush();
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.Message.ToString());
                    End = true;
                    fs.Close();
                }
            }
            LiaisionClient.Close();
 
            MessageBox.Show("Service Arrêté");
        }

Est-ce que je pourrais envoyer des paquets d'octets plutôt ? Si oui combien ?:? Et surtout, comment faire pour lire un fichier par paquet d'octets. Quand je vais arrivé au dernier paquet, il ne fera peut-être pas la même taille que les précédents.:roll: Bref, pourrais tu me donner une piste pour envoyer des âquets d'octets plutôt que 1 à 1 ... :oops: :oops:

Voilà, je ne sais pas comment m'y prendre pour accéler l'envoi ....

06/06/2006, 18h10
dev01

Salut .

il suffit d'envoyer par paquet effectivement, le dernier ne sera pas remplis entierement mais si tu utilises directement les methodes de NetworkStream.Read tu auras le nombre d'octets lus

Pour plus d'info voir la msdn ou l'aide du framework
06/06/2006, 18h19
LE NEINDRE

Dev01,

Dis moi si je me trompe mais networkStream fonctionne uniquement pour les sockets non ?
J'utilise TCPClient là ...

Y a t'il moyen de connaître combien "d'octets" sont remplis avec BinaryReader ?
06/06/2006, 18h48
LE NEINDRE

En d'autre terme, en utilisant ces tcp_client, comment puis-je savoir quand mon fichier est fini d'uploadé (du côté serveur j'entends) ?
06/06/2006, 19h28
dev01

Citation:

Envoyé par LE NEINDRE

Dev01,

Dis moi si je me trompe mais networkStream fonctionne uniquement pour les sockets non ?

oui tu te trompes ... voir la msdn

Bonjour Dev01,

Merci beaucoup !! ça fonctionne :D :D

Je m'étais trompé dans la déclaration du NetworkStream. (je débute :oops: )

Code Faux
Code:

1 2 3 4 5 6 7 8 9 10 11 class service { private TcpClient LiaisionClient = null; private NetworkStream str = null; ... public void Run() { this.str =new NetworkStream(LiaisonClient.GetStream()) } ...
Code juste: (du moins qui fonctionne)
Code:

1 2 3 4 5 6 7 8 9 10 11 class service { private TcpClient LiaisionClient = null; private NetworkStream str = null; ... public void Run() { this.str = LiaisionClient.GetStream(); } ...
Et pour lire ce que l'on reçoit (pile poil le bon nombre d'octets)
Code:

1 2 3 byte[] Bytes = new byte[LiaisionClient.ReceiveBufferSize]; str.Read(Bytes, 0, (int)LiaisionClient.ReceiveBufferSize);
Merci encore Dev01 pour ce coups de main.
Mais j'en viens à me demander quel est l'intéret du BinaryReader pour lire sur un socket ... par rapport à NetworkStream ... ?

Bonne journée !

07/06/2006, 10h36
dev01

Citation:

Envoyé par LE NEINDRE

Mais j'en viens à me demander quel est l'intéret du BinaryReader pour lire sur un socket ... par rapport à NetworkStream ... ?

le binaryReader c'est pour lire un fichier binaire. Enfin c'est comme ça que je l'utilise :mouarf:

Dev01, j'ai peut-être posté un peu trop vite que tout marchait bien.
En réalité, je ne reçoit que des tranches de 8192 octets (côté serveur), alors que j'envoie des tranches de 4096 octets côté client puis une dernière tranche (la fin du fichier inférieure à 4096 octets)

Voilà mon script 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
 
        public void SENDFILE()
        {
            System.IO.FileInfo MonFichier = new System.IO.FileInfo(openFileDialog1.FileName);
            System.IO.FileStream MonFileStream = MonFichier.OpenRead();
            FileStream SRCStream = new FileStream(openFileDialog1.FileName,FileMode.Open, FileAccess.Read);
            int cnt=4096;
            progressBar1.Maximum = (int)MonFichier.Length/4096;
            progressBar1.Step = 1;
 
 
            Thread T1 = new Thread(new ThreadStart(WaitResponse));
 
            while (!End)
            {
                try
                {
 
                    byte[] buffer = new byte[cnt];
                    cnt = SRCStream.Read(buffer, 0, cnt);
                    MessageBox.Show("Octets a envoyer: " + cnt.ToString());
                    if (cnt<4096)
                    {
                        byte[] LastBuffer = new byte[cnt];
                        for(int i=0;i<LastBuffer.Length;i++)
                        {
                            LastBuffer[i]=buffer[i];
                        }
                        Send(LastBuffer);
                        End = true;
                        MessageBox.Show("Dernier Envoie");
                    }
                    else
                    {
                        Send(buffer);
                    }
 
 
 
                }
                catch (Exception E)
                {
                    MessageBox.Show(E.Message);
                    break;
                }
            }
            MessageBox.Show("File uploaded !!!");
            stw.Close();
        }
 
 
        private void Send(byte[] block)
        {
            stw.Write(block, 0, block.Length);
            stw.Flush();
            WaitResponse();
        }

Et le script 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
 
        public void Run()
        {
 
            this.str = LiaisionClient.GetStream();
            this.stw = new StreamWriter(LiaisionClient.GetStream());
            fs = File.Open("d:\\file", FileMode.Create);
            stw.AutoFlush = true;
            while (!End)
            {
                //Lecture
                if (str.CanRead == true)
                {
                    try
                    {
 
                        byte[] Bytes = new byte[LiaisionClient.ReceiveBufferSize];
                        str.Read(Bytes, 0, (int)LiaisionClient.ReceiveBufferSize);
                        fs.Write(Bytes, 0, (int)LiaisionClient.ReceiveBufferSize);
                        //Traitement
                        reponse++;
                        //Ecriture
                        stw.WriteLine(reponse);
 
                        stw.AutoFlush = true;
                        MessageBox.Show(LiaisionClient.ReceiveBufferSize.ToString());
                        if (LiaisionClient.ReceiveBufferSize < 4095)
                        {
                            MessageBox.Show("Dernier echange");
                            End = true;
                        }
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.Message.ToString());
                        End = true;
                        fs.Close();
                        //break;
                    }
                }
                else
                {
                    MessageBox.Show("Connexion Fermée");
                }
             }
            LiaisionClient.Close();
            MessageBox.Show("Service Arrêté");
        }

Du côté client, la messagebox me montre bien que j'envoie 4096 octets puis une dernière tranche < 4096 octets (donnée par la variable cnt)
Mais du côté serveur la messagebox m'affiche toujours 8192 octets

D'où mes deux questions:
1. Pourquoi je lis le double d'octets du côté serveur (8192 au lieu de 4096)
2. Pourquoi je n'arrive pas à détecter que j'envoie moins que 4096 octets (pour la fin du transfert) ...

Merci pour vos réponses !!!!