public void getResult(MathService ms)
{
Console.WriteLine("UDP protocol being used.");
UdpClient client = new UdpClient(4000);
try
{
while (true)
{
var endPoint = new IPEndPoint(IPAddress.Any, 0);
string s = "";
while (true)
{
var receiveBytes = client.Receive(ref endPoint);
s = Encoding.ASCII.GetString(receiveBytes);
if (s == "Close")
{
break;
}
var x = Encoding.ASCII.GetBytes("Result: " + ms.Delegate(s));
client.Send(x, x.Length, endPoint);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void SendResult()
{
IPEndPoint endpoint = new IPEndPoint(localAddr, port);
TcpListener listener = new TcpListener(endpoint);
//listener.Start();
Console.WriteLine(@"Started listening requests at: {0}:{1} ", endpoint.Address, endpoint.Port);
while (true)
{
listener.Start();
string messeage = null;
TcpClient sender = listener.AcceptTcpClient();
byte[] buffer = new byte[sender.ReceiveBufferSize];
Console.WriteLine("Request is accepted");
sender.GetStream().Read(buffer, 0, buffer.Length);
messeage = cleanMessage(buffer);
MathService ms = new MathService();
double res = ms.PerformOperation(messeage);
byte[] bytes = ASCIIEncoding.ASCII.GetBytes("Your answer is " + res);
sender.GetStream().Write(bytes, 0, bytes.Length);
sender.Close();
listener.Stop();
}
}
/// <summary>
/// Constructs new instance of MathServer class.
/// </summary>
/// <param name="ipEndPoint"> Server IP endpoint.</param>
public MathServer(IPEndPoint ipEndPoint)
{
this.ipEndPoint = ipEndPoint;
this.tcpServer = new TcpListener(this.ipEndPoint);
this.udpServer = new UdpClient(this.ipEndPoint);
this.mathService = new MathService();
}
/// <summary>
/// Makes basic math operations.
/// </summary>
/// <param name="operation">Operation with a specified format.</param>
/// <param name="result">The result of operation.</param>
/// <returns>Returns true if operation was successfully done, else returns false.</returns>
private static bool TryDoMathOperation(string operation, out double?result)
{
result = null;
var splitString = operation.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (splitString.Length != 3)
{
return(false);
}
var oper = splitString[0];
double firstOperand;
if (!Double.TryParse(splitString[1], out firstOperand))
{
return(false);
}
double secondOperand;
if (!Double.TryParse(splitString[2], out secondOperand))
{
return(false);
}
MathService service = new MathService();
Operations operations = null;
switch (oper)
{
case "+":
operations += service.Add;
break;
case "-":
operations += service.Sub;
break;
case "*":
operations += service.Mult;
break;
case "/":
if (secondOperand == 0)
{
return(false);
}
operations += service.Div;
break;
default:
return(false);
}
result = operations(firstOperand, secondOperand);
return(true);
}
public void SendResult(MathService ms)
{
//for getting
UdpClient clientget = new UdpClient();
clientget.Client.Bind(new IPEndPoint(IPAddress.Any, port));
//for sending
UdpClient clientsend = new UdpClient();
clientsend.Connect(localAddr, 1000);
try
{
IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 1);
string message = String.Empty;
do
{
var receiveBytes = clientget.Receive(ref RemoteIpEndPoint);
message = Encoding.ASCII.GetString(receiveBytes);
Console.WriteLine(message);
string tiv1 = null;
string tiv2 = null;
string operator1 = null;
Drop(message, ref operator1, ref tiv1, ref tiv2);
ms.num1 = Convert.ToDouble(tiv1);
ms.num2 = Convert.ToDouble(tiv2);
string result = Convert.ToString(ms.PerformOperation(Convert.ToChar(operator1)));
var sendBytes = Encoding.ASCII.GetBytes(result);
clientsend.Send(sendBytes, sendBytes.Length);
Console.WriteLine("worked");
}while (message != "exit");
//closing client
clientget.Close();
clientsend.Close();
}
catch (Exception)
{
Console.WriteLine("Something goes wrong...disconnected");
return;
}
}
static void Main(string[] args)
{
MathService ms = new MathService();
TcpListener listener = null;
StreamReader reader = null;
TcpClient client = null;
string protocol = "";
try
{
listener = new TcpListener(IPAddress.Any, 4000);
listener.Start();
while (true)
{
client = listener.AcceptTcpClient();
reader = new StreamReader(client.GetStream());
protocol = reader.ReadLine();
if (protocol == "TCP" || protocol == "UDP")
{
break;
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
if (listener != null)
{
reader.Close();
client.Close();
listener.Stop();
}
}
IServiceProtocol serviceProtocol;
if (protocol == "TCP")
{
serviceProtocol = new TCP();
}
else
{
serviceProtocol = new UDP();
}
serviceProtocol.getResult(ms);
}
static void Main(string[] args)
{
MathService ms = new MathService();
//creating 2 threads
TCP tcppr = new TCP();
UDP udppr = new UDP();
//getting them methods
Thread tr1 = new Thread(() => tcppr.SendResult(ms));
Thread tr2 = new Thread(() => udppr.SendResult(ms));
//starting the threads
tr1.Start();
tr2.Start();
}
public void ProcessResult()
{
int port = 13000;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
UdpClient listener = new UdpClient(port);
IPEndPoint groupEP = new IPEndPoint(localAddr, port);
Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
try
{
while (true)
{
Console.WriteLine("UDP server is waiting for broadcast... ");
byte[] bytes = listener.Receive(ref groupEP);
Console.WriteLine($"Received broadcast from {groupEP} :");
string data = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
Console.WriteLine($" {data}");
// Process the data sent by the client.
MathService mathService = new MathService();
double result = mathService.PerformOperation(data);
data = result.ToString();
bytes = System.Text.Encoding.ASCII.GetBytes(data);
sock.SendTo(bytes, groupEP);
}
}
catch (SocketException e)
{
Console.WriteLine(e);
}
finally
{
listener.Close();
}
}
/// <summary>
/// getting result using UDP
/// </summary>
/// <param name="ms"></param>
public void getResult(MathService ms)
{
Console.WriteLine("TCP protocol being used");
TcpListener listener = null;
try
{
listener = new TcpListener(IPAddress.Any, 4000);
listener.Start();
while (true)
{
var client = listener.AcceptTcpClient();
var reader = new StreamReader(client.GetStream());
var writer = new StreamWriter(client.GetStream());
string s = reader.ReadLine();
while (s != "Close")
{
writer.WriteLine("Result: {0}", ms.Delegate(s));
writer.Flush();
s = reader.ReadLine();
}
reader.Close();
writer.Close();
client.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
if (listener != null)
{
listener.Stop();
}
}
}
/// <summary>
/// Sends result to the user using TCP protocol
/// </summary>
/// <param name="ms"></param>
public void SendResult(MathService ms)
{
while (true)
{
try
{
TcpListener server = new TcpListener(localAddr, port);
server.Start();
Console.WriteLine("Waiting for connection... ");
TcpClient tcpClient = server.AcceptTcpClient();
Console.WriteLine("Client is connected,doing queary...");
//getting network stream for reading and writing
NetworkStream stream = tcpClient.GetStream();
//Confirming message
string response = "CONNECTED";
byte[] data1 = Encoding.UTF8.GetBytes(response);
//sending message
stream.Write(data1, 0, data1.Length);
string messageString;
do
{
StringBuilder message = new StringBuilder();
byte[] data = new byte[256];
int bytes = stream.Read(data, 0, data.Length);
message.Append(Encoding.UTF8.GetString(data, 0, bytes));
messageString = message.ToString();
Console.WriteLine(messageString);
if (messageString == "exit")
{
break;
}
else if (messageString == "other protocol")
{
break;
}
if (messageString != String.Empty)
{
string tiv1 = null;
string tiv2 = null;
string operator1 = null;
Drop(messageString, ref operator1, ref tiv1, ref tiv2);
ms.num1 = Convert.ToDouble(tiv1);
ms.num2 = Convert.ToDouble(tiv2);
double result = ms.PerformOperation(Convert.ToChar(operator1));
Console.WriteLine("Worked");
string send = Convert.ToString(result);
byte[] data2 = Encoding.UTF8.GetBytes(send);
stream.Write(data2, 0, data2.Length);
}
}while (messageString != String.Empty);
stream.Close();
//closing
tcpClient.Close();
server.Stop();
}
catch (Exception)
{
Console.WriteLine("Something goes wrong...disconnected");
return;
}
}
}
public void ProcessResult()
{
try
{
// TcpListener server = new TcpListener(port);
server = new TcpListener(localAddr, port);
// Start listening for client requests.
server.Start();
// Buffer for reading data
Byte[] bytes = new Byte[256];
String data = null;
// Enter the listening loop.
while (true)
{
Console.Write("TCP server is waiting for a connection... ");
// Perform a blocking call to accept requests.
TcpClient client = server.AcceptTcpClient();
Console.WriteLine("Connected!");
data = null;
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
int i;
// Loop to receive all the data sent by the client.
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
// Translate data bytes to a ASCII string.
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
Console.WriteLine("Received: {0}", data);
// Process the data sent by the client.
MathService mathService = new MathService();
double result = mathService.PerformOperation(data);
data = result.ToString();
byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);
// Send back a response.
stream.Write(msg, 0, msg.Length);
Console.WriteLine("Sent: {0}", data);
}
// Shutdown and end connection
client.Close();
}
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
finally
{
// Stop listening for new clients.
server.Stop();
}
Console.WriteLine("\nHit enter to continue...");
Console.Read();
}
