public void StartClient(string messageToSend, ITextChanger ipTextChanger)
{
try
{
// Create a TcpClient.
// Note, for this client to work you need to have a TcpServer
// connected to the same address as specified by the server, port
// combination.
Int32 port = 13000;
TcpClient client = new TcpClient(server, port);
// Translate the passed message into ASCII and store it as a Byte array.
Byte[] data = System.Text.Encoding.ASCII.GetBytes(messageToSend);
// Get a client stream for reading and writing.
// Stream stream = client.GetStream();
NetworkStream stream = client.GetStream();
// Send the message to the connected TcpServer.
stream.Write(data, 0, data.Length);
Logger.GetInstance().WriteLog("Sent: " + messageToSend);
// Receive the TcpServer.response.
// Buffer to store the response bytes.
data = new Byte[256];
// String to store the response ASCII representation.
String responseData = String.Empty;
// Read the first batch of the TcpServer response bytes.
Int32 bytes = stream.Read(data, 0, data.Length);
responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
Logger.GetInstance().WriteLog("Received: " + responseData);
// Close everything.
//stream.Close();
//client.Close();
}
catch (ArgumentNullException e)
{
Logger.GetInstance().WriteLog("ArgumentNullException: " + e);
}
catch (SocketException e)
{
Logger.GetInstance().WriteLog("SocketException: " + e);
}
}
public void StartReceiving(ITextChanger ipText)
{
// Establish the local endpoint for the socket.
// The DNS name of the computer
// running the listener is "host.contoso.com".
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 13000);
ipText.ChangeText(ipAddress.MapToIPv4().ToString());
// Create a TCP/IP socket.
Socket listener = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
// Bind the socket to the local endpoint and listen for incoming connections.
try
{
listener.Bind(localEndPoint);
listener.Listen(100);
while (true)
{
// Set the event to nonsignaled state.
AllDone.Reset();
// Start an asynchronous socket to listen for connections.
Logger.GetInstance().NotifyAll("Waiting for a connection...");
listener.BeginAccept(
new AsyncCallback(AcceptCallback),
listener);
// Wait until a connection is made before continuing.
AllDone.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public void StartClient(string messageToSend, ITextChanger ipTextChanger)
{
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddress = IPAddress.Parse(server);
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
ipTextChanger.ChangeText(ipAddress.MapToIPv4().ToString());
// Create a TCP/IP socket.
Socket client = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
client.BeginConnect(remoteEP,
new AsyncCallback(connectCallback), client);
connectDone.WaitOne();
send(client, messageToSend + "<EOF>");
sendDone.WaitOne();
// Receive the response from the remote device.
receive(client);
receiveDone.WaitOne();
// Write the response to the console.
Logger.GetInstance().WriteLog("Response received : " + response);
// Release the socket.
client.Shutdown(SocketShutdown.Both);
client.Close();
}
catch (Exception e)
{
Logger.GetInstance().WriteLog(e.ToString());
}
}
public void StartReceiving(ITextChanger ipText)
{
TcpListener server = null;
try
{
// Set the TcpListener on port 13000.
Int32 port = 13000;
IPAddress localAddress = IPAddress.Parse(ipv4Address);
ipText.ChangeText(localAddress.MapToIPv4().ToString());
server = new TcpListener(localAddress, 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)
{
Logger.GetInstance().NotifyAll("Waiting for a connection... ");
// Perform a blocking call to accept requests.
// You could also use server.AcceptSocket() here.
TcpClient client = server.AcceptTcpClient();
Logger.GetInstance().NotifyAll("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);
Logger.GetInstance().NotifyAll("Received: " + data);
List <Message> newMessage = UtilityFunctions.MessageParser(data);
MessageCollection.GetInstance().AddListOfMessages(newMessage);
// Process the data sent by the client.
//data = data.ToUpper();
byte[] msg = System.Text.Encoding.ASCII.GetBytes(newMessage[0].Call());
// Send back a response.
stream.Write(msg, 0, msg.Length);
Logger.GetInstance().NotifyAll("Sent: " + data);
}
// Shutdown and end connection
//client.Close();
}
}
catch (SocketException e)
{
Logger.GetInstance().NotifyAll("SocketException: " + e);
}
finally
{
// Stop listening for new clients.
server.Stop();
Logger.GetInstance().NotifyAll("Server has stopped listening");
}
}
