Hallo,
ich hoffe, ich darf nun gezielt nachfragen.
Verwende ich async und await, werden alle Funktionen schön abgearbeitet.
Die Anwendung hängt nicht.
Alles soweit gut.
Die Fragen
A) Sehe ich das richtig mit dem await, async ?
B) Wie wandle ich die ersten 4 Bytes in eine Zahl um, die ich empfange?
C) Wie wandle ich die Länge eines Strings in 4 Bytes um, für das Senden?
D) Benötige ich im Server noch einen Thread?
Um meine Fragen zu verstehen, dient der untere Code.
Herzlichen Dank im Voraus für Eure Unterstützung und Tipps.
Viele Grüße Martin
Siehe Kommentar.
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
StartListener(); // ### Start
ConnectAsTcpClient(); // ### nahezu zeitgleich aufgerufen
Console.ReadLine();
}
private static async void ConnectAsTcpClient()
{
using (var tcpClient = new TcpClient())
{
Console.WriteLine("[Client] Connecting to server");
await tcpClient.ConnectAsync("127.0.0.1", 1234); // ## hier wird gewartet
// ## bis es zur Verbindung kommt
// ## aber nicht blockierend!
// ## man merkt es nicht.
// ##
Console.WriteLine("[Client] Connected to server");
using (var networkStream = tcpClient.GetStream())
{
Console.WriteLine("[Client] Writing request {0}", ClientRequestString);
await networkStream.WriteAsync(ClientRequestBytes, 0, ClientRequestBytes.Length);
var buffer = new byte[4096];
var byteCount = await networkStream.ReadAsync(buffer, 0, buffer.Length);
// ## hier müsste ich eine Schleife machen,
// ## bis die Anzalh der zu erwartenden Bytes zurückkommt.
var response = Encoding.UTF8.GetString(buffer, 0, byteCount);
Console.WriteLine("[Client] Server response was {0}", response);
}
}
}
private static readonly string ClientRequestString = "Some HTTP request here";
private static readonly byte[] ClientRequestBytes = Encoding.UTF8.GetBytes(ClientRequestString);
private static readonly string ServerResponseString = "<?xml version=\"1.0\" encoding=\"utf-8\"?><document><userkey>key</userkey> <machinemode>1</machinemode><serial>0000</serial><unitname>Device</unitname><version>1</version></document>\n";
private static readonly byte[] ServerResponseBytes = Encoding.UTF8.GetBytes(ServerResponseString);
private static async void StartListener()
{
var tcpListener = TcpListener.Create(1234);
tcpListener.Start();
var tcpClient = await tcpListener.AcceptTcpClientAsync();
Console.WriteLine("[Server] Client has connected");
using (var networkStream = tcpClient.GetStream())
{
var buffer = new byte[4096];
Console.WriteLine("[Server] Reading from client");
var byteCount = await networkStream.ReadAsync(buffer, 0, buffer.Length);
// ## hier müsste ich eine Schleife machen,
// ## bis die Anzahl der zu erwartenden Bytes zurückkommt.
var request = Encoding.UTF8.GetString(buffer, 0, byteCount);
Console.WriteLine("[Server] Client wrote {0}", request);
await networkStream.WriteAsync(ServerResponseBytes, 0, ServerResponseBytes.Length);
Console.WriteLine("[Server] Response has been written");
}
}
}
}
Ich möchte ja nicht immmer neu verbinden.
Benötige ich dann noch einen Thread für den Empfang?
D.h. ich rufe die Read Funktion auf und die pollt solange die Applikation läuft.
private static async void Read()
{
Console.WriteLine("[Server] is ready to for receive messages");
using (var networkStream = tcpClient.GetStream())
{
while(1)
{
// ##### Abbruch wie?
string request = "";
while (bytesMustBe < 287)
// #### oder besser die ersten 4 Bytes geben die Länge vor!
// #### wie wandle ich die ersten 4 Bytes in eine Länge um ?
{
var byteCount = await networkStream.ReadAsync(buffer, 0, buffer.Length);
// ## hier müsste ich eine Schleife machen,
// ## bis die Anzahl der zu erwartenden Bytes zurückkommt.
request += Encoding.UTF8.GetString(buffer, 0, byteCount);
}
Console.WriteLine("[Server] Client wrote {0}", request);
switch (request.Substring(0,10))
{
case "Workflow1"
ServerResponseBytes = "W1" + ServerResponseBytes;
lengthAnswer = ServerResponseBytes.Length;
ServerResponseBytes = <LängeMessage> + ServerResponseBytes;
break;
case "Workflow2"
ServerResponseBytes = "W2" + ServerResponseBytes;
break;
}
await networkStream.WriteAsync(ServerResponseBytes, 0, ServerResponseBytes.Length);
Console.WriteLine("[Server] Response has been written");
}
}
}
await - async - Thread; Task
