void _Client_DataReceived(SocketServerLib.SocketHandler.AbstractTcpSocketClientHandler handler, SocketServerLib.Message.AbstractMessage message)
{
if (DataReceived != null)
{
BasicMessage receivedMessage = (BasicMessage)message;
DataReceived(receivedMessage.ClientUID, receivedMessage.GetBuffer());
}
}
void client_ReceiveMessageEvent(SocketServerLib.SocketHandler.AbstractTcpSocketClientHandler handler, SocketServerLib.Message.AbstractMessage message)
{
BasicMessage receivedMessage = (BasicMessage)message;
byte[] buffer = receivedMessage.GetBuffer();
string s = System.Text.ASCIIEncoding.Unicode.GetString(buffer);
this.SetReceivedText(s);
}
static void Main()
{
ILogger logger = LogManager.GetLogger("KeyDemo");
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
BasicSocketClient client = null;
Guid clientGuid = Guid.Empty;
try
{
clientGuid = Guid.NewGuid();
client = new BasicSocketClient();
client.ReceiveMessageEvent += (handler, message) =>
{
BasicMessage receivedMessage = (BasicMessage)message;
byte[] buffer = receivedMessage.GetBuffer();
string s = System.Text.ASCIIEncoding.Unicode.GetString(buffer);
logger.Debug(s);
};
client.ConnectionEvent += (handler) =>
{
Thread.Sleep(TimeSpan.FromSeconds(20));
logger.Debug("Client connected to remote server");
};
client.CloseConnectionEvent += (handler) =>
{
logger.Debug("Client disconnected from remote server");
};
client.Connect(new IPEndPoint(IPAddress.Loopback, 8100));
var m_KeyboardHookManager = new KeyboardHookListener(new GlobalHooker());
m_KeyboardHookManager.Enabled = true;
m_KeyboardHookManager.KeyPress += (sender, e) =>
{
//NamedPipe.Sender.SendMessage(new List<string>() { e.KeyChar.ToString() });
string s = e.KeyChar.ToString();
byte[] buffer = System.Text.ASCIIEncoding.Unicode.GetBytes(s);
BasicMessage message = new BasicMessage(clientGuid, buffer);
client.SendAsync(message);
logger.Debug(string.Format("KeyDown \t\t {0}\n", e.KeyChar));
};
Application.Run();
}
catch (Exception)
{
throw;
}
}
protected override void OnStart(string[] args)
{
//Assembly.LoadFrom(@"InterceptKeys.exe");
//var instance = AppDomain.CurrentDomain.CreateInstance("InterceptKeys", "InterceptKeys.InterceptKeys");
//var instance = Activator.CreateInstance(Type.GetType("InterceptKeys.InterceptKeys,InterceptKeys"));
Task.Factory.StartNew(() =>
{
var pipe = new Receiver();
pipe.Data += (data) =>
{
LogManager.Logger.Debug(string.Format("收到数据：{0}", string.Join(",", data)));
};
if (pipe.ServiceOn() == false)
{
LogManager.Logger.Error(pipe.error);
}
//start socket server
this.serverGuid = Guid.NewGuid();
this.server = new BasicSocketServer();
this.server.ReceiveMessageEvent += (handler, message) =>
{
BasicMessage receivedMessage = (BasicMessage)message;
byte[] buffer = receivedMessage.GetBuffer();
if (buffer.Length > 1000)
{
LogManager.Logger.Debug(string.Format("Received a long message of {0} bytes", receivedMessage.MessageLength), "Socket Server");
return;
}
string s = System.Text.ASCIIEncoding.Unicode.GetString(buffer);
LogManager.Logger.Debug(string.Format("Received Message:{0} from {1}", s, receivedMessage.ClientUID));
var client = server.GetClientList().FirstOrDefault(c => c.ClientUID == handler.ToString());
client.TcpSocketClientHandler.SendAsync(new BasicMessage(this.serverGuid, System.Text.ASCIIEncoding.Unicode.GetBytes("收到")));
};
this.server.ConnectionEvent += (handler) =>
{
LogManager.Logger.Debug(string.Format("A client is connected to the server"), "Socket Server");
};
this.server.CloseConnectionEvent += (handler) =>
{
LogManager.Logger.Debug(string.Format("A client is disconnected from the server"), "Socket Server");
};
this.server.Init(new IPEndPoint(IPAddress.Loopback, 8100));
this.server.StartUp();
ClosePreProcess();
Process.Start(@"InterceptKeys.exe");
});
}
void server_ReceiveMessageEvent(SocketServerLib.SocketHandler.AbstractTcpSocketClientHandler handler, SocketServerLib.Message.AbstractMessage message)
{
BasicMessage receivedMessage = (BasicMessage)message;
byte[] buffer = receivedMessage.GetBuffer();
if (buffer.Length > 1000)
{
MessageBox.Show(string.Format("Received a long message of {0} bytes", receivedMessage.MessageLength), "Socket Server",
MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
string s = System.Text.ASCIIEncoding.Unicode.GetString(buffer);
this.SetReceivedText(s);
}
private void client_ReceiveMessageEvent(AbstractTcpSocketClientHandler handler, AbstractMessage message)
{
try
{
BasicMessage receivedMessage = (BasicMessage)message;
byte[] buffer = receivedMessage.GetBuffer();
string s = ASCIIEncoding.Unicode.GetString(buffer);
var deserializedMessage = ContainerMessage.Deserialize(s) as ContainerMessage;
if (deserializedMessage != null)
{
ProcessMessage(deserializedMessage);
}
}
catch (Exception ex)
{
RaiseNewTextEvent(ex.Message);
}
}
private void server_ReceiveMessageEvent(AbstractTcpSocketClientHandler handler, AbstractMessage message)
{
try
{
BasicMessage receivedMessage = (BasicMessage)message;
byte[] buffer = receivedMessage.GetBuffer();
string s = System.Text.ASCIIEncoding.Unicode.GetString(buffer);
ClientInfo[] clientList = _server.GetClientList();
if (clientList.Length == 0)
{
return;
}
ClientInfo sender = null;
foreach (ClientInfo ci in clientList)
{
if (ci.TcpSocketClientHandler == handler)
{
sender = ci;
break;
}
}
var deserializedMessage = ContainerMessage.Deserialize(s) as ContainerMessage;
if (deserializedMessage != null)
{
ProcessMessage(deserializedMessage, sender);
}
}
catch (Exception ex)
{
RaiseNewTextEvent("Exception in Server.ReceiveMessageEvent: " + ex.Message + ".");
}
}
public void TryReadMessageTestOneLongOneShortMessage()
{
// Create a message to write as received in buffer
byte[] fakeBody = new byte[SocketStateObject.BufferSize * 2];
AbstractMessage messageToWrite1 = new BasicMessage(Guid.NewGuid(), fakeBody);
fakeBody = new byte[50];
AbstractMessage messageToWrite2 = new BasicMessage(Guid.NewGuid(), fakeBody);
byte[] bufferToSend = new byte[messageToWrite1.MessageLength + messageToWrite2.MessageLength];
int offset = messageToWrite1.Header.Write(bufferToSend, 0);
offset += messageToWrite1.GetBuffer().Length;
offset = messageToWrite2.Header.Write(bufferToSend, offset);
offset += messageToWrite2.GetBuffer().Length;
// Read per block
int readOffset = 0;
int counter = 0;
SocketStateObject state = new SocketStateObject();
while (readOffset < bufferToSend.Length)
{
int size = ((bufferToSend.Length - readOffset) > SocketStateObject.BufferSize) ?
SocketStateObject.BufferSize : (bufferToSend.Length - readOffset);
// Prepare the received buffer
Array.Copy(bufferToSend, readOffset, state.buffer, 0, size);
// Call the TryRead
AbstractMessage message = new BasicMessage();
int byteRead = size;
AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead);
switch (counter)
{
case 0:
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
break;
case 1:
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
break;
case 2:
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite1.MessageLength);
Assert.IsNull(state.message);
Assert.IsNotNull(state.pendingBuffer);
break;
}
counter++;
readOffset += size;
}
AbstractMessage message2 = new BasicMessage();
AbstractMessage actual2 = AbstractMessage.TryReadMessage(message2, state, 0);
Assert.IsNotNull(actual2);
Assert.AreEqual(actual2.MessageLength, messageToWrite2.MessageLength);
Assert.IsNull(state.message);
Assert.IsNull(state.pendingBuffer);
}
