public void Send()
{
using (var socket = new Socket(SocketType.Stream, ProtocolType.Tcp)) {
socket.NoDelay = true;
socket.Bind(new IPEndPoint(IPAddress.Loopback, 12000));
socket.Listen(1);
using (var client = new FeatherTcpClient <BinaryMessage>()) {
client.Connect("127.0.0.1", 12000);
var socketa = socket.Accept();
client.Send(TestMessage1);
client.Send(TestMessage2);
Thread.Sleep(10);
var buffer = new byte[TestWire1.Length];
var pos = 0;
while (pos < buffer.Length)
{
var len = socketa.Receive(buffer, pos, TestWire1.Length - pos, SocketFlags.None);
pos += len;
}
Assert.Equal(TestWire1, buffer);
buffer = new byte[TestWire2.Length];
pos = 0;
while (pos < buffer.Length)
{
var len = socketa.Receive(buffer, pos, TestWire2.Length - pos, SocketFlags.None);
pos += len;
}
Assert.Equal(TestWire2, buffer);
}
}
}
public void ClientDisconnected()
{
var stage = 0;
var block = new AutoResetEvent(false);
using (var socket = new Socket(SocketType.Stream, ProtocolType.Tcp)) {
socket.NoDelay = true;
socket.Bind(new IPEndPoint(IPAddress.Loopback, 12003));
socket.Listen(1);
using (var client = new FeatherTcpClient <BinaryMessage>()) {
client.OnDisconnected += (reason) => {
Assert.Equal(0, stage++);
block.Set();
};
client.Connect("127.0.0.1", 12003);
var socketa = socket.Accept();
Thread.Sleep(10);
socketa.Shutdown(SocketShutdown.Both);
socketa.Dispose();
block.WaitOne(1000);
Assert.Equal(1, stage);
}
}
}
public void Send_NotConnected()
{
var client = new FeatherTcpClient <BinaryMessage>();
Assert.Throws <InvalidOperationException>(() => {
client.Send(TestMessage1);
});
}
public async Task Secure()
{
var state = 0;
var block = new AutoResetEvent(false);
var raw = File.ReadAllBytes("localhost.pfx");
var certificate = new X509Certificate2(raw, "test");
using (var server = new FeatherTcpServer <BinaryMessage>()) {
server.OnMessageReceived += (endPoint, message) => {
if (state == 0)
{
Assert.Equal(TestPayload1, message.Export().ToArray());
state++;
}
else if (state == 1)
{
Assert.Equal(TestPayload2, message.Export().ToArray());
state++;
block.Set();
}
else
{
throw new Exception();
}
};
server.ListenSecure(13008, certificate);
using (var client = new FeatherTcpClient <BinaryMessage>()) {
await client.ConnectSecureAsync("localhost", 13008, "localhost", (object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors sslPolicyErrors) => {
return(true); // Ignore that it's a self-signed cert
});
await client.SendAsync(TestMessage1);
await client.SendAsync(TestMessage2);
block.WaitOne(1000);
}
}
Assert.Equal(2, state);
}
static void Main(string[] args)
{
Console.WriteLine("What is your name?");
var myName = Console.ReadLine();
using (var client = new FeatherTcpClient <GenericMessage>()) {
// Watch for messages to arrive
client.OnMessageReceived += (message) => {
// Read parameters in the same order they were written
var name = message.ReadString();
var body = message.ReadString();
Console.WriteLine($"{name}> {body}");
};
// Watch for disconnetion
client.OnDisconnected += (reason) => {
Console.WriteLine($"Disconnected because '{reason}'.");
};
// Connect to server
client.Connect("127.0.0.1", 12345);
// Loop sending messages
Console.WriteLine("Connected. Type message to send.");
while (true)
{
var body = Console.ReadLine();
if (body == string.Empty)
{
break;
}
// Create message
var message = new GenericMessage();
message.WriteString(myName);
message.WriteString(body);
// Send message to broadcast address
client.Send(message);
}
}
}
public void Receive()
{
var stage = 0;
var block = new AutoResetEvent(false);
using (var socket = new Socket(SocketType.Stream, ProtocolType.Tcp)) {
socket.NoDelay = true;
socket.Bind(new IPEndPoint(IPAddress.Loopback, 12004));
socket.Listen(1);
using (var client = new FeatherTcpClient <BinaryMessage>()) {
client.OnMessageReceived += (message) => {
if (stage == 0)
{
Assert.Equal(TestPayload1, message.Export().ToArray());
stage = 1;
}
else if (stage == 1)
{
Assert.Equal(TestPayload2, message.Export().ToArray());
stage = 2;
block.Set();
}
else
{
Assert.False(true);
}
};
client.Connect("127.0.0.1", 12004);
var socketa = socket.Accept();
Assert.True(socketa.Connected);
socketa.Send(TestWire1);
Thread.Sleep(10);
socketa.Send(TestWire2);
block.WaitOne(1000);
}
}
Assert.Equal(2, stage);
}
public async Task Dispose()
{
using (var socket = new Socket(SocketType.Stream, ProtocolType.Tcp)) {
socket.NoDelay = true;
socket.Bind(new IPEndPoint(IPAddress.Loopback, 12006));
socket.Listen(1);
var client = new FeatherTcpClient <BinaryMessage>();
client.Connect("127.0.0.1", 12006);
Assert.False(client.IsDisposed);
client.Dispose();
Assert.True(client.IsDisposed);
Assert.Throws <ObjectDisposedException>(() => {
client.Send(TestMessage1);
});
await Assert.ThrowsAsync <ObjectDisposedException>(async() => {
await client.SendAsync(TestMessage1);
});
}
}
public bool Connect(string ip, int port)
{
client = new FeatherTcpClient <GenericMessage>();
client.OnDisconnected += (endPoint) =>
{
Console.WriteLine($"{endPoint} disconnected.");
};
client.OnMessageReceived += OnReceived;
try
{
client.Connect(ip, port);
}
catch
{
return(false);
}
Console.WriteLine("Connected to server");
return(true);
}
