[C#] Utilisation de NetworkStream

**LE NEINDRE** · 06/06/2006, 15h21

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 !!!

**dev01** · 06/06/2006, 16h15

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.

**LE NEINDRE** · 06/06/2006, 16h35

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 :

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
 
        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 :

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
 
        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.

Bref, pourrais tu me donner une piste pour envoyer des âquets d'octets plutôt que 1 à 1 ...

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

**dev01** · 06/06/2006, 19h10

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

**LE NEINDRE** · 06/06/2006, 19h19

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 ?

**LE NEINDRE** · 06/06/2006, 19h48

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) ?

**dev01** · 06/06/2006, 20h28

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

**LE NEINDRE** · 07/06/2006, 10h54

Bonjour Dev01,

Merci beaucoup !! ça fonctionne

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

)

Code Faux

Code :

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

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 :

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

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 :

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

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 !

**dev01** · 07/06/2006, 11h36

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

**LE NEINDRE** · 07/06/2006, 11h50

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 :

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
 
        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 :

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
 
        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 !!!!

[C#] Utilisation de NetworkStream

Windows Forms

Discussions similaires

Partager

Partager