| Autor |
Beitrag |
Ccenter
 
Beiträge: 154
Win7
C#
|
Verfasst: So 01.08.10 18:58
Hallo,
ich habe vor, über ein Chatprogramm auch Dateien versenden zu können.
Der Chat und das Versenden laufen ansich auch soweit, nur habe ich ein Problem mit dem Anlagen von Bytes.
Zum Senden/Empfangen habe ich folgenden Code geschrieben:
Senden:
  C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
| TcpClient client = new TcpClient();
client.Connect(ip, 2000);
NetworkStream stream = client.GetStream();
FileStream fs = File.OpenRead(@"C:\Users\Ccenter\Desktop\testbild1.jpg");
byte[] bytes = new byte[fs.Length];
fs.Read(bytes, 0, bytes.Length);
stream.Write(bytes, 0 , bytes.Length); |
Empfangen:
C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
| NetworkStream stream = client.GetStream();
FileStream fs = new FileStream(@"C:\Users\Ccenter\Desktop\Output\test.jpg", FileMode.Create);
byte[] bytes = new byte[1000];
stream.Read(bytes, 0, bytes.Length);
fs.Read(bytes, 0, bytes.Length);
Console.WriteLine("gelesen");
fs.Write(bytes, 0, bytes.Length); |
Der Code funktioniert auch wunderbar, nur lege ich im Moment 1000 Bytes an. Das kann in vielen Fällen für z.B. Bilder zu klein sein. Wenn ich den Wert jetzt auf 1000000 Bytes lege, ist das aber möglicherweise schon wieder zu viel, so dass die Datei am Ende viel größer ist als die Ausgangsdatei.
Deshalb brauche ich eine Möglichkeit, nur so viele zu verwenden, wie die gesendete Datei benötigt. Nur bin ich an dieser Stelle mit meinem Latein leider am Ende 
Kann mir da einer weiter helfen?
Zuletzt bearbeitet von Ccenter am So 08.08.10 20:33, insgesamt 1-mal bearbeitet
|
|
Trashkid2000
Beiträge: 561
Erhaltene Danke: 137
|
Verfasst: So 01.08.10 20:13
Hi Ccenter,
dass mit dem statischen Byte-Array zum empfangen ist natürlich unpraktisch, da man nie weiss, wie viele Daten denn übertragen werden. Deswegen nimmt man so ein Byte-Array als Puffer (in diesem Fall 1 KB) und liest den empfangenden Stream blockweise.
Ich machs einfach mal kurz und zeige, wie es denn zum empfangen aussehen müsste.
C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
| NetworkStream networkStream = client.GetStream();
FileStream fs = new FileStream(@"C:\Users\Ccenter\Desktop\Output\test.jpg", FileMode.Create);
Byte[] buffer = new Byte[1024];
long total = networkStream.Length;
long current = 0;
int read;
do
{
read = networkStream.Read(buffer, 0, buffer.Length);
fs.Write(buffer, 0, read);
current += read;
} while (total != current);
networkStream.Close();
fs.Close(); |
Viel Erfolg dabei, Marko
Für diesen Beitrag haben gedankt: Ccenter
|
|
Ccenter 
Beiträge: 154
Win7
C#
|
Verfasst: So 01.08.10 20:51
Ersteinmal vielen Dank, das wird mir auf jeden Fall schonmal weiter helfen.
Jedoch bekomme ich während das Programm ausgeführt wird, bei
"long total = networkStream.Length;"
diese Fehlermeldung: "Dieser Stream unterstützt keine Suchvorgänge."
Ich hab das dann gegoogled und hab bei msdn das gefunden:
"Der Hauptunterschied zwischen der NetworkStream-Klasse und anderen Streams besteht darin, dass NetworkStream keine Suchvorgänge unterstützt."
( msdn.microsoft.com/d...89t%28VS.80%29.aspx)
|
|
Kha
Beiträge: 3803
Erhaltene Danke: 176
Arch Linux
Python, C, C++ (vim)
|
Verfasst: So 01.08.10 21:51
Wenn der Client nicht die Größe der Datei kennen kann, muss es der Server ihm eben sagen: Schicke vor den Daten erst einmal deren Länge ab.
_________________ >λ=
|
|
Ccenter
Beiträge: 154
Win7
C#
|
Verfasst: So 08.08.10 20:02
Ok, die Dateigröße vorher abzuschicken habe ich nun eingebaut, zumindest schonmal theoretisch da es beim testen in einer leeren Anwendung geklappt hat.
Der Grund dafür, dass ich es nich nicht eingebaut habe, ist nämlich das ich leider auf ein großes Problem gestoßen bin.
Von wegen | Zitat: | | Der Code funktioniert auch wunderbar |
...zu früh gefreut
Ich kann zwar eine Datei versenden und auch empfangen, allerdings kommt diese dann nur noch in Bruchstücken an. Bei Bildern z.B. nur 1/3 des Bildes (die unteren 2/3 sind einfach weiß). Bei Musik kommen nur die ersten paar sekunden an.
Was nur komisch ist, die Lieder haben die richtige Länge und auch die Größe die sie besitzen müssten. Der Player zeigt dann an, dass das Lied z.B. eine Dauer von 3.40 hat, spielt jedoch nur die ersten Sekunden ab und springt dann wieder an den Anfang, spielt aber nichts mehr ab. So als wäre das Lied fertig. Ok, die Größe gebe ich selber vor, ich weiß jetzt nicht ob die Länge des Liedes im direkten Zusammenhang mit der Bytezahl steht. Ich denke aber eigendlich eher nicht.
Naja, der Grund das ich den Fehler erst jetzt bemerke: Ich habe vorher den Clienten und den Server auf dem gleichen Pc laufen lassen, weil mein zweiter Pc für paar Tage nicht verwendbar war. Nun wo ich das auf dem testen konnte, ist mir dieser Fehler aufgefallen.
So wie das für mich aussieht, ist es so als ob in die Datei nur ein Teil der Daten reingeschrieben werden und der Resst einfach weggelassen wird.
Jetzt fragt sich nur, weshalb das nur im Netzwerk auftritt. Ich habs bereits noch auf einem anderen Pc getestet, es liegt definitiv nicht am Zweitpc, dass nur ein Teil der Daten ankommt. Ich werde versuchen das gleich mit nem Freund noch ausserhalb des Netzwerkes auszuprobieren, ich berichte dann!
Hier nochmal der Code, etwas vervollständigter:
Senden:
C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
|
TcpClient client = new TcpClient();
client.Connect(ip, 2000);
NetworkStream stream = client.GetStream();
FileStream fs = File.OpenRead(@"C:\Users\Ccenter\Desktop\testbild1.jpg");
byte[] bytes = new byte[fs.Length];
fs.Read(bytes, 0, bytes.Length);
stream.Write(bytes, 0 , bytes.Length);
fs.Close(); |
Empfangen:
C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
| TcpListener listener = new TcpListener(2000);
listener.Start;
TcpClient connection = new TcpClient();
connection = Listener.AcceptTcpClient();
NetworkStream stream = client.GetStream();
FileStream fs = new FileStream(@"C:\Users\Ccenter\Desktop\Output\test.jpg", FileMode.Create);
byte[] bytes = new byte[1000];
stream.Read(bytes, 0, bytes.Length);
fs.Read(bytes, 0, bytes.Length);
Console.WriteLine("gelesen");
fs.Write(bytes, 0, bytes.Length);
fs.Close(); |
Bei der Suche im Internet hatte jemand ein sehr ähnliches Problem(dort gabs aber nicht wirklich eine Lösung...), zumindest hat dort einer dazu gesagt, dass der Fehler darin liegt, dann man zuviele Bytes in den Networkstream schreiben will. Mir persönlich das nicht zu der Lösung aber vielleicht kann hier ja jemand was damit anfangen. Ich denke mein Problem beruht auf dem gleichen Problem.
Edit1: Ich habs jetzt noch einmal mit einer 65 Bytes großen Textdatei ausprobiert, die Übertragung davon funktioniert.
Edit2: Mit einer 3500 Bytes großen png-Datei funktioniert es auch noch, mit einer 27050 Bytes großen Jpg nicht mehr. Das Ergebniss sieht so aus:
(Das Bild müsste eigendlich 2/3 länger sein. Diese schwarz-grünen Quadrate gehören da eigendlich auch nicht hin)
Einloggen, um Attachments anzusehen!
|
|
Kha
Beiträge: 3803
Erhaltene Danke: 176
Arch Linux
Python, C, C++ (vim)
|
Verfasst: So 08.08.10 21:18
Schau dir noch einmal Trashkid2000s Code an, besonders die Schleife  . ( using-Blöcke für die Streams dürft ihr aber beide gern benutzen) _________________ >λ=
|
|
Ccenter
Beiträge: 154
Win7
C#
|
Verfasst: Mo 09.08.10 16:34
Ok, hab nun seinen Code genommen:
Empfangen:
C#-Quelltext
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:
| TcpClient client = new TcpClient();
TcpListener listener = new TcpListener(2001);
listener.Start();
client = listener.AcceptTcpClient();
NetworkStream stream = client.GetStream();
FileStream fs = new FileStream(@"C:\Users\Ccenter \Desktop\bild.png", FileMode.Create);
Byte[] buffer = new Byte[1024];
long total = 1802240;
long current = 0;
int read;
do
{
read = stream.Read(buffer, 0, buffer.Length);
fs.Write(buffer, 0, read);
current += read;
} while (total != current);
stream.Close();
fs.Close(); |
Senden: (Hier müsste der Fehler stecken):
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:
| try
{
TcpClient client = new TcpClient();
client.Connect(ip, 2001 );
NetworkStream stream = client.GetStream();
FileStream fs = File.OpenRead(@"C:\Users\Ccenter2\Desktop\bild.png");
Byte[] buffer = new Byte[1024];
long total = fs.Length;
long current = 0;
int read;
do
{
read = fs.Read(buffer, 0, buffer.Length);
stream.Write(buffer, 0, read);
current += read;
} while (total != current);
stream.Close();
fs.Close();
this.Close();
}
catch
{
MessageBox.Show("failed");
this.Close();
} |
Sobald der Empfänger gestartet wird und ich versuche mich zu verbinden, erstellt er auch seine Bilddatei. Problem ist nur wieder, dass die Datei unvollständig ist. Jedoch war von der jpg-Datei die ich hier in den Anhang gesetzt hatte, schon mehr zu sehen. Als ich es mit einer png probiert habe, war sie fast vollständig dar.
Jedoch wird immer noch nicht alles übertragen. Ausserdem sollten sich die Probgramme ja schließen sobald sie fertig sind. Jedoch schließt nur der Sender sich. Der Empfänger versucht immer noch zu empfangen. Das bedeutet ja nur wieder, dass der Sender frühzeitig aufhört zu senden =(
|
|
Ccenter
Beiträge: 154
Win7
C#
|
Verfasst: Sa 14.08.10 15:42
Ich bin jetzt nochmal diverse Firewalleinstellungen durchgegangen, habs an anderen Pc's ausprobiert, Ports geändert etc.
Immer das gleiche Ergebniss. Der Fehler liegt also definitiv im Code.
Mit googlen bin ich am Ende, hat mir auch nicht viel geholfen. Jemand ne Idee was im Code dazu führt, dass frühzeitig aufgehört wird zu senden?
|
|
Trashkid2000
Beiträge: 561
Erhaltene Danke: 137
|
Verfasst: So 15.08.10 09:30
Hi CCenter,
Also, ich denke mal schon, dass der Sender alles sendet. Das Problem ist eher der Empfänger, denn da hast Du statisch angegeben, wieviel Bytes geschickt werden.
Und zwar hier:
C#-Quelltext
1:
2:
3:
| Byte[] buffer = new Byte[1024];
long total = 1802240;
long current = 0; |
So, und da der Networkstream keine Abfrage der Länge unterstützt, muss das ganze also anders gelöst werden.
z.B. so:
Empfänger:
C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
| Byte[] buffer = new Byte[1024];
int read = buffer.Length;
while (read == buffer.Length)
{
read = stream.Read(buffer, 0, buffer.Length);
fs.Write(buffer, 0, read);
} |
Wurde getestet und funktioniert. Was ich allerdings bei dem ganzen nicht verstehe ist, woher soll der Empfänger wissen, was für eine Datei geschickt wird? Also woran machst Du die Dateiendung aus?
Ach ja, und dann packe mal noch alle Streams in using-Blöcke,
@Kha hat ja Recht!
Gutes Gelingen, Marko
|
|
Ccenter
Beiträge: 154
Win7
C#
|
Verfasst: So 15.08.10 17:30
Ersteinmal ein großes Dankeschön, einige Dateien werden jetzt schon ganz übertragen =)
Ersteinmal zu deiner Frage bezüglich der Dateiendung: Momentan, in der "Testphase", wo der Code ansich ersteinmal funktionieren soll, lass ich die Dateiendung noch nicht auslesen sondern schreibe sie noch manuel in den Code. Wenn der soweit läuft, lasse ich das dann wohl über Substrings auslesen.
Leider funktioniert der Code aber immer noch nicht ganz so wie er soll.
Hier der aktuelle Code:
Sender:
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:
| private void Form1_Load(object sender, EventArgs e)
{
try
{
TcpClient client = new TcpClient();
client.Connect(ip, 80);
NetworkStream stream = client.GetStream();
FileStream fs = File.OpenRead(sendDirectory);
Byte[] buffer = new Byte[1024];
long total = fs.Length;
long current = 0;
int read;
do
{
read = fs.Read(buffer, 0, buffer.Length);
stream.Write(buffer, 0, read);
current += read;
} while (total != current);
stream.Close();
fs.Close();
}
catch
{
}
this.Close();
} |
Empfänger:
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:
| private void Form1_Load(object sender, EventArgs e)
{
TcpClient client = new TcpClient();
TcpListener listener = new TcpListener(80);
listener.Start();
client = listener.AcceptTcpClient();
NetworkStream stream = client.GetStream();
using (FileStream fs = new FileStream(@"C:\Users\Ccenter\Desktop\bild.jpg", FileMode.Create))
{
Byte[] buffer = new Byte[1024];
int read = buffer.Length;
while (read == buffer.Length)
{
read = stream.Read(buffer, 0, buffer.Length);
fs.Write(buffer, 0, read);
}
fs.Close();
}
stream.Close();
this.Close();
} |
Ich habe zuerst auch beim Sender versucht using-Blöcke einzubauen, dann hat der Sender aber nicht alles übertragen. Gut, das tut er jetzt meißtens auch nicht, jedoch sind es mit using-Blöcken weniger Bytes.
Zuletzt bearbeitet von Ccenter am So 15.08.10 18:38, insgesamt 1-mal bearbeitet
|
|
Kha
Beiträge: 3803
Erhaltene Danke: 176
Arch Linux
Python, C, C++ (vim)
|
Verfasst: So 15.08.10 18:18
AFAIK kann Read auch vor dem Ende mal eine Zahl < 1024 zurückgeben. Nur eine 0 zeigt eindeutig an, dass die TCP-Verbindung geschlossen wurde.
_________________ >λ=
|
|
Trashkid2000
Beiträge: 561
Erhaltene Danke: 137
|
Verfasst: Mo 16.08.10 17:51
Also, habe mich nochmal an das Thema rangesetzt. Obwohl ich auf Arbeit auch viele Probleme habe. Aber alles, was != WPF ist, ist mir irgendwie sympatischer.
@Kha
Naja, Read gibt ja die im Stream gelesenen Bytes zurück. Also wenn < als Puffergröße, dann ist entweder der Stream zu Ende oder abgebrochen. Aber wenn er abgebrochen ist, müsste es auch eine Exception geben. Ober liege ich mit meiner Vermutung falsch?
@CCenter
Wenn Du eine Ressource in einen Using-Block packst, kannst Du dir das Close() sparen. Das macht der Block selber, wenn er beendet wird. Ein Open() ist dagegen bei bestimmten Ressourcen notwendig.
Habe nun mal beim Sender den Sendepuffer und beim Empfänger den Empfangspuffer auf max gestellt, der war default auf 8192.
Und das Timeout habe ich auch bei beiden hochgesetzt. Habe im Testbetrieb keine Probleme gehabt, gesendete Bytes und empfangende waren beide immer gleich.
Hier mal der Code:
Sender:
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:
| try
{
using (TcpClient tcpClient = new TcpClient("localhost", 2000))
{
Console.WriteLine("Connected to Server");
tcpClient.SendBufferSize = int.MaxValue; tcpClient.SendTimeout = 30000;
using (NetworkStream clientSockStream = tcpClient.GetStream())
{
long sendedBytes;
using (StreamWriter clientStreamWriter = new StreamWriter(clientSockStream))
{
using (FileStream fs = File.OpenRead(@"C:\temp\ITest2.cs"))
{
Byte[] buffer = new Byte[1024];
int current = 0;
int read = buffer.Length;
while (read == buffer.Length)
{
read = fs.Read(buffer, 0, buffer.Length);
clientSockStream.Write(buffer, 0, read);
current += read;
}
sendedBytes = fs.Length;
}
}
Console.WriteLine(sendedBytes + " Bytes gesendet");
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
} |
Empfänger:
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:
| try
{
TcpListener tcpServerListener = new TcpListener(2000);
tcpServerListener.Start(); Console.WriteLine("Server gestartet");
using (Socket serverSocket = tcpServerListener.AcceptSocket())
{
serverSocket.ReceiveBufferSize = int.MaxValue; serverSocket.ReceiveTimeout = 30000; if (serverSocket.Connected)
{
using (NetworkStream serverSocketStream = new NetworkStream(serverSocket))
{
Byte[] buffer = new Byte[1024];
using (BinaryReader socketStreamReader = new BinaryReader(serverSocketStream))
{
using (FileStream fs = new FileStream(@"C:\temp\ITest2__.cs", FileMode.Create))
{
int current = 0;
int read = buffer.Length;
while (read == buffer.Length)
{
read = socketStreamReader.Read(buffer, 0, buffer.Length);
fs.Write(buffer, 0, read);
current += read;
}
Console.WriteLine(fs.Length + " Bytes empfangen");
}
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
} |
Kannst Du ja mal ausprobieren. Ansonsten bin ich mit mein Latein auch erstmal am Ende und weiss nicht, an was es dann noch hapern könnte.
LG, Marko
|
|
Kha
Beiträge: 3803
Erhaltene Danke: 176
Arch Linux
Python, C, C++ (vim)
|
Verfasst: Mo 16.08.10 18:35
|
|
Trashkid2000
Beiträge: 561
Erhaltene Danke: 137
|
Verfasst: Mo 16.08.10 19:31
|
|
Ccenter
Beiträge: 154
Win7
C#
|
Verfasst: Mo 23.08.10 15:09
Moin,
ich hatte die letzte Woche aufgrund von Schule keine Zeit an dem Projekt weiter zu arbeiten.
Ich hab mich übers Wochenende aber wieder ran gesetzt und es im Netzwerk zum laufen bekommen =)
Vielen Dank für eure Hilfe! Ich werde es die nächsten Tage nochmal direkt über Internet ausprobieren aber ich denke, da sollte es dann ja eigendlich keine Probleme mehr geben wenns eh im Netzwerk läuft.
Nochmal vielen Dank, auch für die Geduld
|
|
Trashkid2000
Beiträge: 561
Erhaltene Danke: 137
|
Verfasst: Mo 23.08.10 16:47
 Ccenter hat folgendes geschrieben  : |
Ich hab mich übers Wochenende aber wieder ran gesetzt und es im Netzwerk zum laufen bekommen =)
|
Schön, wäre auch gut zu wissen, wie Du es nun zum laufen gebracht hast, bzw., woran es nun lag.
|
|
Ccenter
Beiträge: 154
Win7
C#
|
Verfasst: Mo 23.08.10 17:17
Ja klar, kommt gleich.
Zuerst: Ich hab es gerade mit nem Kumpel übers Internet probiert und es funktioniert. Was nur sehr schade ist, dass die Übertragungsrate wirklich ziemlich langsam ist. Für 5 mb mussten wir 5.40 Minuten warten. Ich denke aber, dass das nicht am Programm lag, sondern eher an der Leitung.
Beim Code hat es ausgereicht (Danke an Kha)
das hier zu berücksichtigen:
| Zitat: | | AFAIK kann Read auch vor dem Ende mal eine Zahl < 1024 zurückgeben. Nur eine 0 zeigt eindeutig an, dass die TCP-Verbindung geschlossen wurde. |
Demnach war dein Code schon richtig, es hat nur noch eine Bedingung gefehlt.
Mit diesem Code lief es dann:
C#-Quelltext
1:
| while ((read <= buffer.Length) && (read != 0)) |
|
|
Kha
Beiträge: 3803
Erhaltene Danke: 176
Arch Linux
Python, C, C++ (vim)
|
Verfasst: Mo 23.08.10 18:53
Gut, dass es jetzt funktioniert, aber wie viel Sinn die Bedingung vor dem && macht, solltest du dir noch einmal überlegen . _________________ >λ=
|
|
Ccenter
Beiträge: 154
Win7
C#
|
Verfasst: Sa 11.12.10 17:54
Als Hauptprojekt arbeite ich momentan an einer Neuauflage meines alten Chats der noch per Konsole lief. Jetzt soll alles über Gui laufen und im Gegensatz zum alten Chat, die Dateisendefunktion auch innerhalb des Chatprogramms laufen. Damals hatte ich große Probleme das Textempfangen und Dateiempfangen in einem Programm unter zu bringen. Deshalb hatte ich das über eine zweite Anwendung laufen lassen, die dann von der Hauptanwendung gestartet wurde um die Datei zu emfangen.
Jetzt möchte ich das alles in einer einzigen Hauptanwendung unterbringen. Jedoch hab ich wieder das alter Problem: Wenn das Empfängerprogramm den Sender des anderen Programmes auffordert zu senden, scheint der TextReceiver im Empfängerprogramm die zu empfangenen Bytes abzufangen.
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:
| public NetworkStream fileReceiver;
public NetworkStream textReceiver;
public void fileReceive()
{
while (true)
{
using (FileStream fs = new FileStream(ReceiverDir, FileMode.Create))
{
Byte[] buffer = new Byte[1024];
int read = buffer.Length;
while ((read <= buffer.Length) & (read != 0))
{
read = fileReceiver.Read(buffer, 0, buffer.Length); fs.Write(buffer, 0, read);
}
fileReceiver.Close();
fs.Close();
}
}
}
public void textReceive()
{
while (true)
{
byte[] RecPacket = new byte[5000];
textReceiver.Read(RecPacket, 0, RecPacket.Length);
textReceiver.Flush();
tring txt = Encoding.ASCII.GetString(RecPacket);
txt = txt.Trim();
ShowReceivedText();
}
}
|
Sobald ich fertig empfange, kommt diese Fehlermeldung:
Auf das verworfene Objekt kann nicht zugegriffen werden.
Objektname: "System.Net.Sockets.NetworkStream".
Ich empfange alles, erst wenn er fertig mit Empfangen ist kommt die Meldung. Ich habe gerade testweise versucht eine Txt-Datei zu versenden, im Fenster wo normalerweise der empfangene Text erscheint, erschien eben der Inhalt der Txt-Datei.
Um Text und Dateien gleichzeitig empfangen zu können habe ich jeweils einen NetworkStream deklariert. Im Sender ebenfalls. Jedoch weiß ich nicht wie ich den Networkstreams einen jeweiliegen Networkstream zuweise an den gesendet werden soll. Das würde wohl das Problem beheben, dass die Textreceiver-Methode die Bytes der Datei empfängt...
|
|
Yogu
Beiträge: 2598
Erhaltene Danke: 156
Ubuntu 13.04, Win 7
C# (VS 2013)
|
Verfasst: Sa 11.12.10 18:43
Hallo,
ein NetworkStream ist keine eigenständige Netzwerk-Komponente, sondern empfängt nur über einen Socket Daten. Es nützt also nichts, zwei NetworkStreams zu erstellen, die beide an ein Socket gebunden sind. Stattdessen brauchst du zwei Socket; einen für den Chat und einen für die Textübertragung. Beachte, dass beide unterschiedliche Ports brauchen.
Ich würde vorschlagen, den Sender einen Listener an einem beliebigen Port öffnen zu lassen und über den Chat-Stream die Portnummer des Listeners zu übermitteln. Der Empfänger muss dann auch einen Socket an diesem Port erstellen und die Datei empfangen.
|
|
|
