public SyncIOClient(TransportProtocol protocol, Packager packager)
{
Protocol = protocol;
_packager = packager;
_callbacks = new CallbackManager <SyncIOClient>();
_remoteFunctions = new RemoteFunctionManager();
_callbacks.SetHandler <HandshakePacket>((c, p) =>
{
_handshakeComplete = p.Success;
_connection.SetID(p.Id);
_handshakeEvent?.Set();
_handshakeEvent?.Dispose();
_handshakeEvent = null;
OnHandshake?.Invoke(this, ID, _handshakeComplete);
_callbacks.RemoveHandler <HandshakePacket>();
});
_callbacks.SetHandler <RemoteCallResponse>((c, p) => _remoteFunctions.RaiseFunction(p));
}
public SyncIOClient(TransportProtocal _protocal, Packager _packager)
{
Protocal = _protocal;
Packager = _packager;
Callbacks = new CallbackManager <SyncIOClient>();
RemoteFunctions = new RemoteFunctionManager();
Callbacks.SetHandler <HandshakePacket>((c, p) => {
HandshakeComplete = p.Success;
Connection.SetID(p.ID);
HandshakeEvent?.Set();
HandshakeEvent?.Dispose();
HandshakeEvent = null;
OnHandshake?.Invoke(this, ID, HandshakeComplete);
Callbacks.RemoveHandler <HandshakePacket>();
});
Callbacks.SetHandler <RemoteCallResponse>((c, p) => {
RemoteFunctions.RaiseFunction(p);
});
}
public void TestCallbacks()
{
var objectTest = new object[] {
"Test",
1,
22f,
55.7m,
new int[] { 1, 2, 3, 4, 5 }
};
var TestClass1 = new Test1(55);
var callbacks = new CallbackManager <testClient>();
var Client1 = new testClient();
var Client2 = new testClient();
callbacks.SetArrayHandler((testClient client, object[] d) =>
{
Assert.AreEqual(client, Client1);
CollectionAssert.AreEqual(d, objectTest);
});
callbacks.SetHandler <Test1>((testClient client, Test1 t) =>
{
Assert.AreEqual(client, Client2);
Assert.AreEqual(TestClass1, t);
});
callbacks.Handle(Client1, new ObjectArrayPacket(objectTest));
callbacks.Handle(Client2, TestClass1);
callbacks.SetPacketHandler((testClient client, IPacket p) =>
{
Assert.AreEqual(client, Client1);
Assert.IsInstanceOfType(p, typeof(Test2));
});
callbacks.Handle(Client1, new Test2());
callbacks.SetPacketHandler((testClient client, IPacket p) =>
{
Assert.AreNotEqual(client, Client1);
Assert.IsNotInstanceOfType(p, typeof(Test2));
});
callbacks.Handle(Client2, new Test3());
}
/// <summary>
/// Add handler for IPacket type receve
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="callback"></param>
public void SetHandler <T>(Action <SyncIOClient, T> callback) where T : class, IPacket
{
Callbacks.SetHandler <T>(callback);
}
public void SetHandler <T>(Action <SecureSocketClient, T> callback) where T : class, IPacket
{
_callbacks.SetHandler(callback);
}