private async void WaitForMessage()
{
bool wait = true;
byte[] receivedData = new byte[BUFFER];
int downloadedBytes = 0;
while (wait)
{
try
{
NetworkStream stream = client.GetStream();
downloadedBytes = await stream.ReadAsync(receivedData, 0, receivedData.Length);
string receivedMessage = System.Text.Encoding.ASCII.GetString(receivedData, 0, downloadedBytes);
MessageFunction?.Invoke($"Otrzymałem: {receivedMessage}");
string newMessage = DoSomeWork(receivedMessage);
SendMessage(newMessage);
}
catch (Exception)
{
MessageFunction?.Invoke("Klient się odłączył");
wait = false;
}
}
}
public async void ClientConnect()
{
try
{
await client.ConnectAsync(serverIp, port);
}
catch (Exception)
{
}
Message message = new Message()
{
SendTime = DateTime.Now,
Nick = nick
};
if (client.Connected)
{
string serverIp = GetServerIp();
message.Text = $"Połączyłem się z [{serverIp}]";
}
else
{
message.Text = $"Błąd połączenia";
}
MessageFunction?.Invoke(message);
messageWaiting = new Task(() => WaitForMessage());
messageWaiting.Start();
}
public void SendMessage(string message)
{
try
{
Message messageToSend = new Message()
{
SendTime = DateTime.Now,
Nick = nick,
Text = message
};
var serializer = new BinaryFormatter();
serializer.Serialize(stream, messageToSend);
/**
* using (MemoryStream memStream = new MemoryStream())
* {
* serializer.Serialize(memStream, messageToSend);
* byte[] dataToSend = memStream.GetBuffer();
* await stream.WriteAsync(dataToSend, 0, (int)memStream.Length);
* }*/
}
catch (Exception)
{
Message mess = new Message()
{
SendTime = DateTime.Now,
Nick = nick,
Text = "Serwer zakończył działanie."
};
MessageFunction?.Invoke(mess);
return;
}
}
public async void WaitForMessage()
{
bool wait = true;
while (wait)
{
try
{
MessageFunction?.Invoke("Ozcekuję na wiadomości...");
//receivedData = server.Receive(ref client);
var result = await server.ReceiveAsync();
client = result.RemoteEndPoint;
string receivedMessage = System.Text.Encoding.ASCII.GetString(result.Buffer);
MessageFunction?.Invoke($"Wiadomość z {client.ToString()}");
MessageFunction?.Invoke($"Treść: {receivedMessage}");
string messageToSendBack = DoSomeWork(receivedMessage);
SendBack(messageToSendBack);
}
catch (Exception)
{
wait = false;
MessageFunction?.Invoke("Przerywam działanie");
}
}
}
private async void SendMessage(string message)
{
byte[] dataToSend = new byte[BUFFER];
NetworkStream stream = client.GetStream();
dataToSend = System.Text.Encoding.ASCII.GetBytes(message);
await stream.WriteAsync(dataToSend, 0, dataToSend.Length);
MessageFunction?.Invoke($"Wysłałem: {message}");
}
public async void WaitForClient()
{
client = await listener.AcceptTcpClientAsync();
//client = listener.AcceptTcpClient();
string clientIp = GetClientIp();
MessageFunction?.Invoke($"Klient podłączony. [{clientIp}]");
WaitForMessage();
}
private async void WaitForMessage()
{
byte[] receivedData = new byte[BUFFER];
NetworkStream stream = client.GetStream();
int downloadedBytes = await stream.ReadAsync(receivedData, 0, receivedData.Length);
string receivedMessage = System.Text.Encoding.ASCII.GetString(receivedData, 0, downloadedBytes);
MessageFunction?.Invoke($"Otrzymałem: {receivedMessage}");
}
private async void WaitForMessage()
{
try
{
var result = await client.ReceiveAsync();
string receivedMessage = System.Text.Encoding.ASCII.GetString(result.Buffer);
MessageFunction?.Invoke($"Odebrałem: {receivedMessage}");
}
catch (Exception)
{
MessageFunction?.Invoke("Przerywam działanie");
}
}
public async void SendMessage(string message)
{
byte[] dataToSend = System.Text.Encoding.ASCII.GetBytes(message);
try
{
await client.SendAsync(dataToSend, dataToSend.Length);
MessageFunction?.Invoke("Wysłałem wiadomość.");
WaitForMessage();
}
catch (Exception)
{
MessageFunction?.Invoke("Nie udało się wysłać wiadomości");
}
}
private void WaitForMessage()
{
stream = client.GetStream();
while (client.Connected)
{
try
{
/**
* using (MemoryStream memStream = new MemoryStream())
* {
* //First Aproach
* byte[] receivedBytes = new byte[BUFFER];
*
* int receivedBytesLength = await stream.ReadAsync(receivedBytes, 0, receivedBytes.Length);
*
* memStream.Write(receivedBytes, 0, receivedBytesLength);
* memStream.Seek(0, SeekOrigin.Begin);
*
* // We are sending all the data in one package
* var serializer = new BinaryFormatter();
* Message receivedMessage = (Message)serializer.Deserialize(memStream);
* }
*/
// Second Aproach
var serializer = new BinaryFormatter();
Message receivedMessage = (Message)serializer.Deserialize(stream);
MessageFunction?.Invoke(receivedMessage);
}
catch (Exception exc)
{
Message mess = new Message()
{
SendTime = DateTime.Now,
Nick = nick,
Text = "Błąd pobierania wiadomości. Serwer nie odpowiada?." + exc.Message
};
MessageFunction?.Invoke(mess);
}
}
stream.Close();
}
public async void SendMessage(string message)
{
byte[] dataToSend = new byte[BUFFER];
try
{
NetworkStream stream = client.GetStream();
dataToSend = System.Text.Encoding.ASCII.GetBytes(message);
await stream.WriteAsync(dataToSend, 0, dataToSend.Length);
}
catch (Exception)
{
MessageFunction?.Invoke("Serwer zakończył działanie.");
return;
}
MessageFunction?.Invoke($"Wysłałem: {message}");
WaitForMessage();
}
public async void ClientConnect()
{
try
{
await client.ConnectAsync(serverIp, port);
}
catch (Exception)
{
}
if (client.Connected)
{
string serverIp = GetServerIp();
MessageFunction?.Invoke($"Połączyłem się z [{serverIp}]");
}
else
{
MessageFunction?.Invoke("Nie udało się połączyć...");
}
}
public void StartListening()
{
listener.Start();
MessageFunction?.Invoke("Rozpocząłem nasłuch");
}
