/// <summary>
/// call method sync
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connector"></param>
/// <param name="serviceName"></param>
/// <param name="methodName"></param>
/// <param name="args"></param>
/// <returns></returns>
public static T SendDataSync <T>(this ConnectorBase connector, string serviceName, string methodName, params Shared.Models.ParameterInfo[] args)
{
string data = SendData(connector, serviceName, methodName, args);
if (string.IsNullOrEmpty(data))
{
return(default(T));
}
return(ClientSerializationHelper.DeserializeObject <T>(data.ToString()));
}
/// <summary>
/// send data to client
/// </summary>
/// <typeparam name="T">return type data</typeparam>
/// <param name="client">client for send data</param>
/// <param name="serviceName">method name</param>
/// <param name="args">argumants of method</param>
/// <returns></returns>
internal static T SendData <T>(this OperationCalls client, string serviceName, params Shared.Models.ParameterInfo[] args)
{
object data = SendData(client, serviceName, "", args);
if (data == null || data.ToString() == "")
{
return(default(T));
}
return(ClientSerializationHelper.DeserializeObject <T>(data.ToString()));
}
internal static async Task <T> SendData <T>(this ConnectorBase connector, MethodCallInfo callInfo)
{
string data = await SendDataAsync(connector, callInfo);
#endif
if (string.IsNullOrEmpty(data))
{
return(default(T));
}
return(ClientSerializationHelper.DeserializeObject <T>(data.ToString()));
}
internal static Task <T> SendDataAsync <T>(this ConnectorBase connector, MethodInfo method, MethodCallInfo callInfo, object[] args)
{
#if (NET40 || NET35)
return(Task <T> .Factory.StartNew(() =>
#else
return Task.Run(async() =>
#endif
{
callInfo.Parameters = method.MethodToParameters(x => ClientSerializationHelper.SerializeObject(x), args).ToArray();
#if (NET40 || NET35)
string result = SendData(connector, callInfo);
#else
string result = await SendDataAsync(connector, callInfo);
#endif
object deserialeResult = ClientSerializationHelper.DeserializeObject(result, typeof(T));
return (T)deserialeResult;
}));
}
static ConnectorExtensions()
{
CSCodeInjection.InvokedClientMethodAction = (client, method, parameters) =>
{
//Console.WriteLine($"CSCodeInjection.InvokedClientMethodAction {method.Name}");
//if (!(client is OperationCalls))
//{
// AutoLogger.LogText($"cannot cast! {method.Name} params {parameters?.Length}");
//}
SendDataInvoke((OperationCalls)client, method.Name, parameters);
};
CSCodeInjection.InvokedClientMethodFunction = (client, method, parameters) =>
{
//Console.WriteLine($"CSCodeInjection.InvokedClientMethodFunction {method.Name}");
object data = SendData((OperationCalls)client, method.Name, "", parameters);
if (data == null)
{
return(null);
}
return(data is StreamInfo ? data : ClientSerializationHelper.DeserializeObject(data.ToString(), method.ReturnType));
};
}
private static string SendData(this ConnectorBase connector, MethodCallInfo callInfo)
{
//TryAgain:
bool isIgnorePriority = false;
try
{
TaskCompletionSource <MethodCallbackInfo> valueData = new TaskCompletionSource <MethodCallbackInfo>();
CancellationTokenSource ct = new CancellationTokenSource();
ct.Token.Register(() => valueData.TrySetCanceled(), useSynchronizationContext: false);
bool added = WaitedMethodsForResponse.TryAdd(callInfo.Guid, valueData);
object service = connector.Services.ContainsKey(callInfo.ServiceName) ? connector.Services[callInfo.ServiceName] : null;
//#if (PORTABLE)
MethodInfo method = service?.GetType().FindMethod(callInfo.MethodName);
//#else
// var method = service?.GetType().FindMethod(callInfo.MethodName, RuntimeTypeHelper.GetMethodTypes(service.GetType(), callInfo).ToArray());
//#endif
//
isIgnorePriority = method?.GetCustomAttributes <PriorityCallAttribute>().Count() > 0;
connector.SendData(callInfo);
MethodCallbackInfo result = valueData.Task.Result;
if (result == null)
{
if (connector.IsDisposed)
{
throw new ObjectDisposedException("Provider");
}
if (!connector.IsConnected)
{
throw new Exception("client disconnected");
}
return(null);
}
if (result.IsException)
{
throw new Exception("server exception:" + ClientSerializationHelper.DeserializeObject <string>(result.Data));
}
else if (result.IsAccessDenied && result.Data == null)
{
throw new Exception("server permission denied exception.");
}
return(result.Data);
}
catch (Exception ex)
{
if (connector.IsConnected && !connector.SendPingAndWaitToReceive())
{
connector.Disconnect();
}
throw ex;
}
finally
{
WaitedMethodsForResponse.Remove(callInfo.Guid);
}
}
