public void Register <T>(
T value,
Action <T, string> callback) where T : struct, Enum
{
var method = Ssci.Register(value, callback);
MethodIds.Add(method.Id);
}
public void Register(
string methodId,
Action <string, string> callback)
{
var method = Ssci.Register(methodId, callback);
MethodIds.Add(method.Id);
}
public void Register(
string methodId,
Expression <Action> implementExpression)
{
var method = Ssci.Register(methodId, implementExpression);
MethodIds.Add(method.Id);
}
public void Register <TInterface, TDelegate>(
Expression <Action <TInterface> > interfaceExpression,
Expression <TDelegate> implementExpression)
where TDelegate : Delegate
{
var method = Ssci.Register(interfaceExpression, implementExpression);
MethodIds.Add(method.Id);
}
public void Register <TDelegate>(
string methodId,
Expression <TDelegate> implementExpression)
where TDelegate : Delegate
{
var method = Ssci.Register(methodId, implementExpression);
MethodIds.Add(method.Id);
}
public void Register <TInterface>(
Expression <Action <TInterface> > interfaceExpression,
Expression <Action> implementExpression)
where TInterface : class
{
var method = Ssci.Register(interfaceExpression, implementExpression);
MethodIds.Add(method.Id);
}
public void Invoke(string methodId, IPeer peer, ResponseCallback responseCallback, params object[] objects)
{
Ssci.Invoke(methodId, peer, responseCallback, (serializable) => {
foreach (var item in objects)
{
serializable.SerializableObject(item);
}
});
}
public void Invoke <T>(Func <Expression <Action <T> > > func, ResponseCallback responseCallback)
{
var methodTuple = RpcRequestManager.CreateMethodTuple(func);
var methodId = methodTuple.RpcMethod.GetId();
if (!Connections.TryGetValue(methodId, out var peer))
{
Logger.Warn($"服务器端没有注册{methodId}方法！");
return;
}
Ssci.Invoke(func, peer, responseCallback);
}
public void Invoke(string methodId, IPeer peer, dynamic func, dynamic[] objects)
{
if (string.IsNullOrEmpty(methodId))
{
throw new ArgumentException(nameof(methodId));
}
if (peer == null)
{
throw new ArgumentNullException(nameof(peer));
}
ResponseCallback responseCallback = (rm, sd) => {
func?.Invoke(rm, sd);
};
Ssci.Invoke(methodId, peer, responseCallback, PacketShell(objects));
}
public void TestRpcService()
{
PoolAllocator <IWriteStream> .SetPool((arguments => new WriteStream()));
Ssci.Invoke <ITest>(() => (rpc) => rpc.Test(200), null, null);
}
public static void Invoke(string methodId, IPeer peer, ResponseCallback responseCallback, Action <ISerializable> action)
{
Ssci.Invoke(methodId, peer, responseCallback, action);
}
public void Invoke <T>(Func <Expression <Action <T> > > func, IPeer peer, ResponseCallback responseCallback)
{
Ssci.Invoke(func, peer, responseCallback);
}
