/// <summary>
/// 释放锁
/// </summary>
/// <param name="returnParameter"></param>
private void onExit(AutoCSer.Net.TcpServer.ReturnValue <ReturnParameter> returnParameter)
{
if (returnParameter.Type != Net.TcpServer.ReturnType.Success && AutoCSer.Threading.SecondTimer.Now.Ticks < timeoutTicks)
{
AutoCSer.Threading.SecondTimer.InternalTaskArray.AppendNext(exit);
}
}
/// <summary>
/// 客户端异步 await 测试
/// </summary>
/// <returns></returns>
internal static async System.Threading.Tasks.Task <bool> TestCaseAsync()
{
using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IClientAwaiterServer> .Create(new ClientAwaiter()))
{
if (server.IsListen)
{
IClientAwaiter client = AutoCSer.Net.TcpInternalServer.Emit.Client <IClientAwaiter> .Create();
using (client as IDisposable)
{
AutoCSer.Net.TcpServer.ReturnValue <int> sum = await client.Add(2, 3);
if (sum.Type != AutoCSer.Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
sum2 = 0;
AutoCSer.Net.TcpServer.ReturnValue returnValue = await client.Add2(3, 5);
if (returnValue.Type != AutoCSer.Net.TcpServer.ReturnType.Success || sum2 != 3 + 5)
{
return(false);
}
return(true);
}
}
}
return(false);
}
/// <summary>
/// 同步函数客户端 async / await 测试
/// </summary>
/// <returns></returns>
internal static bool TestCase()
{
#region 步代理调用
AutoCSer.Net.TcpServer.ReturnValue <int> sum = AutoCSer.Example.TcpStaticStreamServer.TcpCallStream.ClientTaskAsync.Add(2, 3);
if (sum.Type != Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
#endregion
#region Awaiter.Wait()
sum = AutoCSer.Example.TcpStaticStreamServer.TcpCallStream.ClientTaskAsync.AddAwaiter(2, 3).Wait().Result;
if (sum.Type != Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
#endregion
#region async 同步调用
sum = AutoCSer.Example.TcpStaticStreamServer.TcpCallStream.ClientTaskAsync.AddAsync(2, 3).Result;
if (sum.Type != Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
#endregion
return(true);
}
/// <summary>
/// 释放锁
/// </summary>
/// <param name="returnParameter"></param>
private void onExit(AutoCSer.Net.TcpServer.ReturnValue <ReturnParameter> returnParameter)
{
if (returnParameter.Type != Net.TcpServer.ReturnType.Success && Date.NowTime.Now.Ticks < timeoutTicks)
{
AutoCSer.Threading.TimerTask.Default.Add(exit, Date.NowTime.Now.AddTicks(Date.SecondTicks));
}
}
/// <summary>
/// 部署任务状态更新日志回调
/// </summary>
/// <param name="log"></param>
private void onLog(AutoCSer.Net.TcpServer.ReturnValue <AutoCSer.Deploy.Log> log)
{
if (log.Type == Net.TcpServer.ReturnType.Success)
{
Client.OnGetLog(name, log.Value);
}
}
/// <summary>
/// 异步回调注册测试
/// </summary>
/// <param name="left">加法左值</param>
/// <param name="right">加法右值</param>
/// <param name="count">回调次数</param>
/// <returns>保持异步回调</returns>
public AutoCSer.Net.TcpServer.KeepCallback Add(int left, int right, int count, Action <AutoCSer.Net.TcpServer.ReturnValue <int> > _onReturn_)
{
AutoCSer.Net.Callback <AutoCSer.Net.TcpServer.ReturnValue <TcpOpenServer._p2> > _onOutput_ = _TcpClient_.GetCallback <int, TcpOpenServer._p2>(_onReturn_);
try
{
AutoCSer.Net.TcpOpenServer.ClientSocketSender _socket_ = _TcpClient_.Sender;
if (_socket_ != null)
{
TcpOpenServer._p1 _inputParameter_ = new TcpOpenServer._p1
{
left = left,
right = right,
count = count,
};
return(_socket_.GetKeep <TcpOpenServer._p1, TcpOpenServer._p2>(_ac0, ref _onOutput_, ref _inputParameter_));
}
}
finally
{
if (_onOutput_ != null)
{
AutoCSer.Net.TcpServer.ReturnValue <TcpOpenServer._p2> _outputParameter_ = new AutoCSer.Net.TcpServer.ReturnValue <TcpOpenServer._p2> {
Type = AutoCSer.Net.TcpServer.ReturnType.ClientException
};
_onOutput_.Call(ref _outputParameter_);
}
}
return(null);
}
/// <summary>
/// 无需 TCP 远程函数申明配置测试
/// </summary>
/// <returns></returns>
//[AutoCSer.Metadata.TestMethod]
internal static bool TestCase()
{
using (AutoCSer.Example.TcpOpenStreamServer.NoAttribute.TcpOpenStreamServer server = new AutoCSer.Example.TcpOpenStreamServer.NoAttribute.TcpOpenStreamServer())
{
if (server.IsListen)
{
using (AutoCSer.Example.TcpOpenStreamServer.TcpStreamClient.NoAttribute.TcpOpenStreamClient client = new AutoCSer.Example.TcpOpenStreamServer.TcpStreamClient.NoAttribute.TcpOpenStreamClient())
{
AutoCSer.Net.TcpServer.ReturnValue <int> sum = client.Add(2, 3);
if (sum.Type != AutoCSer.Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
#region Awaiter.Wait()
sum = client.AddAwaiter(2, 3).Wait().Result;
if (sum.Type != Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
#endregion
return(true);
}
}
}
return(false);
}
/// <summary>
/// 申请锁回调
/// </summary>
/// <param name="returnParameter"></param>
private void enter(AutoCSer.Net.TcpServer.ReturnValue <ReturnParameter> returnParameter)
{
try
{
if (Interlocked.CompareExchange(ref enterLock, 1, 0) == 0)
{
this.returnParameter = returnParameter;
if (returnParameter.Value.Parameter.ReturnType == ReturnType.Success)
{
randomNo = returnParameter.Value.Parameter.Int64.ULong;
timeout = Date.NowTime.Now.AddTicks(timeoutTicks - Date.SecondTicks);
if (Step == Step.None)
{
Step = Step.Lock;
return;
}
exit();
}
}
else if (returnParameter.Value.Parameter.ReturnType == ReturnType.Success)
{
randomNo = returnParameter.Value.Parameter.Int64.ULong;
timeout = Date.NowTime.Now.AddTicks(timeoutTicks - Date.SecondTicks);
exit();
}
}
finally { enterWait.Set(); }
}
/// <summary>
/// 同步函数客户端 async / await 测试
/// </summary>
/// <param name="left">加法左值</param>
/// <param name="right">加法右值</param>
public async System.Threading.Tasks.Task <AutoCSer.Net.TcpServer.ReturnValue <int> > AddAsync(int left, int right)
{
AutoCSer.Net.TcpOpenServer.ClientSocketSender _socket_ = _TcpClient_.Sender;
if (_socket_ != null)
{
AutoCSer.Net.TcpServer.TaskAsyncReturnValue <TcpOpenServer._p2> _wait_ = new AutoCSer.Net.TcpServer.TaskAsyncReturnValue <TcpOpenServer._p2>();
TcpOpenServer._p1 _inputParameter_ = new TcpOpenServer._p1
{
left = left,
right = right,
};
AutoCSer.Net.TcpServer.ReturnType _returnType_;
TcpOpenServer._p2 _outputParameter_ = new TcpOpenServer._p2
{
};
if ((_returnType_ = _socket_.GetAsync <TcpOpenServer._p1, TcpOpenServer._p2>(_a0, _wait_, ref _inputParameter_, ref _outputParameter_)) == AutoCSer.Net.TcpServer.ReturnType.Success)
{
AutoCSer.Net.TcpServer.ReturnValue <TcpOpenServer._p2> _returnOutputParameter_ = await _wait_;
return(new AutoCSer.Net.TcpServer.ReturnValue <int> {
Type = _returnOutputParameter_.Type, Value = _returnOutputParameter_.Value.Return
});
}
return(new AutoCSer.Net.TcpServer.ReturnValue <int> {
Type = _returnType_
});
}
return(new AutoCSer.Net.TcpServer.ReturnValue <int> {
Type = AutoCSer.Net.TcpServer.ReturnType.ClientException
});
}
/// <summary>
/// 申请锁回调
/// </summary>
/// <param name="returnParameter"></param>
private void enter(AutoCSer.Net.TcpServer.ReturnValue <ReturnParameter> returnParameter)
{
if (Interlocked.CompareExchange(ref enterLock, 1, 0) == 0)
{
if (returnParameter.Value.Parameter.ReturnType == ReturnType.Success)
{
randomNo = returnParameter.Value.Parameter.Int64.ULong;
timeout = Date.NowTime.Now.AddTicks(timeoutTicks - Date.SecondTicks);
if (Step == Step.None)
{
Step = Step.Lock;
onEnter(this);
}
else
{
exit();
}
}
else
{
onEnter(new ReturnValue <AsynchronousTimeoutManager> {
Type = returnParameter.Value.Parameter.ReturnType, TcpReturnType = returnParameter.Type
});
}
}
else if (returnParameter.Value.Parameter.ReturnType == ReturnType.Success)
{
randomNo = returnParameter.Value.Parameter.Int64.ULong;
timeout = Date.NowTime.Now.AddTicks(timeoutTicks - Date.SecondTicks);
exit();
}
}
/// <summary>
/// 字段支持 测试
/// </summary>
/// <returns></returns>
//[AutoCSer.Metadata.TestMethod]
internal static bool TestCase()
{
using (AutoCSer.Example.TcpOpenServer.Field.TcpOpenServer server = new AutoCSer.Example.TcpOpenServer.Field.TcpOpenServer())
{
if (server.IsListen)
{
using (AutoCSer.Example.TcpOpenServer.TcpClient.Field.TcpOpenClient client = new AutoCSer.Example.TcpOpenServer.TcpClient.Field.TcpOpenClient())
{
server.Value.GetField = 2;
AutoCSer.Net.TcpServer.ReturnValue <int> value = client.GetField;
if (value.Type != AutoCSer.Net.TcpServer.ReturnType.Success || value.Value != 2)
{
return(false);
}
server.Value.SetField = 0;
client.SetField = 3;
if (server.Value.SetField != 3)
{
return(false);
}
return(true);
}
}
}
return(false);
}
/// <summary>
/// 同步函数客户端 async / await 测试
/// </summary>
/// <returns></returns>
//[AutoCSer.Metadata.TestMethod]
internal static bool TestCase()
{
using (AutoCSer.Example.TcpInternalServer.ClientTaskAsync.TcpInternalServer server = new AutoCSer.Example.TcpInternalServer.ClientTaskAsync.TcpInternalServer())
{
if (server.IsListen)
{
using (AutoCSer.Example.TcpInternalServer.ClientTaskAsync.TcpInternalClient client = new AutoCSer.Example.TcpInternalServer.ClientTaskAsync.TcpInternalClient())
{
#region 步代理调用
AutoCSer.Net.TcpServer.ReturnValue <int> sum = client.Add(2, 3);
if (sum.Type != Net.TcpServer.ReturnType.Success && sum.Value != 2 + 3)
{
return(false);
}
#endregion
#region async 同步调用
sum = client.AddAsync(2, 3).Result;
if (sum.Type != Net.TcpServer.ReturnType.Success && sum.Value != 2 + 3)
{
return(false);
}
#endregion
return(true);
}
}
}
return(false);
}
/// <summary>
/// 同步函数客户端异步测试
/// </summary>
/// <returns></returns>
internal static bool TestCase()
{
#region 步代理调用
AutoCSer.Net.TcpServer.ReturnValue <int> sum = AutoCSer.Example.TcpStaticServer.TcpCall.ClientAsynchronous.Add(2, 3);
if (sum.Type != Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
#endregion
#region Awaiter.Wait()
sum = AutoCSer.Example.TcpStaticServer.TcpCall.ClientAsynchronous.AddAwaiter(2, 3).Wait().Result;
if (sum.Type != Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
#endregion
#region 异步代理调用
sum = default(AutoCSer.Net.TcpServer.ReturnValue <int>);
sumWait.Reset();
AutoCSer.Example.TcpStaticServer.TcpCall.ClientAsynchronous.Add(2, 3, value =>
{
sum = value;
sumWait.Set();
});
sumWait.WaitOne();
if (sum.Type != Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
#endregion
return(true);
}
/// <summary>
/// 同步函数客户端异步测试
/// </summary>
/// <param name="left">加法左值</param>
/// <param name="right">加法右值</param>
public void Add(int left, int right, Action <AutoCSer.Net.TcpServer.ReturnValue <int> > _onReturn_)
{
AutoCSer.Net.Callback <AutoCSer.Net.TcpServer.ReturnValue <TcpOpenServer._p2> > _onOutput_ = _TcpClient_.GetCallback <int, TcpOpenServer._p2>(_onReturn_);
AutoCSer.Net.TcpOpenServer.ClientSocketSender _socket_ = null;
try
{
_socket_ = _TcpClient_.Sender;
if (_socket_ != null)
{
TcpOpenServer._p1 _inputParameter_ = new TcpOpenServer._p1
{
left = left,
right = right,
};
_socket_.Get <TcpOpenServer._p1, TcpOpenServer._p2>(_ac0, ref _onOutput_, ref _inputParameter_);
}
}
finally
{
if (_onOutput_ != null)
{
AutoCSer.Net.TcpServer.ReturnValue <TcpOpenServer._p2> _outputParameter_ = new AutoCSer.Net.TcpServer.ReturnValue <TcpOpenServer._p2> {
Type = _socket_ == null ? AutoCSer.Net.TcpServer.ReturnType.ClientSocketNull : AutoCSer.Net.TcpServer.ReturnType.ClientException
};
_onOutput_.Call(ref _outputParameter_);
}
}
}
/// <summary>
/// 加载缓存数据
/// </summary>
/// <param name="parameter"></param>
internal void Load(AutoCSer.Net.TcpServer.ReturnValue <CacheReturnParameter> parameter)
{
if (parameter.Type == AutoCSer.Net.TcpServer.ReturnType.Success)
{
load(ref parameter.Value.LoadData);
}
}
/// <summary>
/// 创建短路径
/// </summary>
/// <returns></returns>
internal async Task <ReturnValue <nodeType> > CreateTask()
{
if (node != null)
{
do
{
socketIdentity = Client.SocketIdentity;
AutoCSer.Net.TcpServer.ReturnValue <ReturnParameter> value = await Client.QueryAwaiter(Parameter);
if (socketIdentity == Client.SocketIdentity)
{
if (isCreate(ref value))
{
return((nodeType)this);
}
return(new ReturnValue <nodeType> {
Type = Identity.Type, TcpReturnType = Identity.TcpReturnType
});
}
}while (true);
}
return(new ReturnValue <nodeType> {
Type = ReturnType.CanNotCreateShortPath
});
}
/// <summary>
/// 目标对象
/// </summary>
public async Task <MemberValue <valueType> > ValueAsync()
{
switch (state)
{
case MemberState.Unknown:
if (Size == 0)
{
return new MemberValue <valueType> {
State = state = MemberState.Remote
}
}
;
Server.TcpInternalClient client = ClientPool.Get(Index);
if (client == null)
{
return new MemberValue <valueType> {
State = MemberState.NoClient
}
}
;
SubBuffer.PoolBufferFull buffer = default(SubBuffer.PoolBufferFull);
SubBuffer.Pool.GetBuffer(ref buffer, Size);
try
{
AutoCSer.Net.TcpServer.ReturnValue <ClientBuffer> clientBuffer = await client.readAwaiter(new ClientBuffer { Buffer = new SubArray <byte>(buffer.StartIndex, Size, buffer.Buffer), IsClient = true }, Index);
onRead(ref clientBuffer);
}
finally { buffer.Free(); }
break;
}
return(new MemberValue <valueType> {
Value = value, State = state
});
}
/// <summary>
/// 日志流数据处理
/// </summary>
/// <param name="data"></param>
private void onLog(AutoCSer.Net.TcpServer.ReturnValue <Log <valueType, modelType> .Data> data)
{
if (isError == 0)
{
if (data.Type == Net.TcpServer.ReturnType.Success)
{
try
{
if (isLoaded)
{
if (client.onLog(ref data.Value))
{
return;
}
}
else
{
switch (data.Value.Type)
{
case LogType.Insert: array.Add(data.Value.Value.Value); return;
case LogType.Loaded: client.load(ref array); isLoaded = true; return;
}
}
}
catch (Exception error)
{
client.log.Exception(error, null, LogLevel.Exception | LogLevel.AutoCSer);
}
}
this.error();
}
}
internal static bool TestCase()
{
using (AutoCSer.Net.TcpOpenServer.Server server = AutoCSer.Net.TcpOpenServer.Emit.Server <IInherit> .Create(new Inherit()))
{
if (server.IsListen)
{
IInherit client = AutoCSer.Net.TcpOpenServer.Emit.Client <IInherit> .Create();
using (client as IDisposable)
{
AutoCSer.Net.TcpServer.ReturnValue <int> sum = ((IInheritA)client).Add(2, 3);
if (sum.Type != AutoCSer.Net.TcpServer.ReturnType.Success && sum.Value != 2 + 3 + 1)
{
return(false);
}
sum = ((IInheritB)client).Add(2, 3);
if (sum.Type != AutoCSer.Net.TcpServer.ReturnType.Success && sum.Value != 2 + 3 + 2)
{
return(false);
}
sum = client.AddOnly(2, 3);
return(sum.Type == AutoCSer.Net.TcpServer.ReturnType.Success && sum.Value == 2 + 3);
}
}
}
return(false);
}
public override void Call()
{
AutoCSer.Net.TcpInternalSimpleServer.ServerSocket socket = Socket;
AutoCSer.Net.TcpServer.ReturnValue <_p2> value = new AutoCSer.Net.TcpServer.ReturnValue <_p2>();
get(ref value);
push(this);
socket.SendAsync(_c5, ref value);
}
internal static ReturnValue <KeyValue <ulong, returnType> > Get(ref AutoCSer.Net.TcpServer.ReturnValue <IdentityReturnParameter> value)
{
if (value.Value.Parameter.ReturnType == ReturnType.Success)
{
return(new KeyValue <ulong, returnType>(value.Value.Identity, ValueData.Data <returnType> .GetData(ref value.Value.Parameter)));
}
return(new ReturnValue <KeyValue <ulong, returnType> >(ref value));
}
/// <summary>
/// 消息超时追加到文件完毕
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
internal bool OnAppendFile(AutoCSer.Net.TcpServer.ReturnValue <ReturnParameter> value)
{
if (value.Type == Net.TcpServer.ReturnType.Success)
{
reader.SetIdentity(identity);
}
return(true);
}
/// <summary>
/// 异步回调测试
/// </summary>
/// <returns></returns>
internal static bool TestCase()
{
AutoCSer.Net.TcpServer.ReturnValue <int> sum = AutoCSer.Example.TcpStaticSimpleServer.TcpCallSimple.Asynchronous.Add(2, 3);
if (sum.Type != Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
{
return(false);
}
return(true);
}
public void Callback(AutoCSer.Net.TcpServer.ReturnValue <int> value)
{
AutoCSer.TestCase.WebPerformance.Ajax.Call ajax = System.Threading.Interlocked.Exchange(ref Ajax, null);
if (ajax != null)
{
Parameter.Return = value.Value;
response(ajax, value.Type);
}
}
public void Callback(AutoCSer.Net.TcpServer.ReturnValue <@MethodReturnType.FullName> value)
{
@WebAjaxMethodType.FullName ajax = System.Threading.Interlocked.Exchange(ref Ajax, null);
if (ajax != null)
{
Parameter.Return = value.Value;
response(ajax, value.Type);
}
}
private void get(ref AutoCSer.Net.TcpServer.ReturnValue <_p2> value)
{
try
{
AutoCSer.Web.SearchServer.SearchItem[] Return;
Return = AutoCSer.Web.SearchServer.Server /**/.TcpStaticServer._M1(inputParameter.p0);
value.Value.Return = Return;
value.Type = AutoCSer.Net.TcpServer.ReturnType.Success;
}
catch (Exception error)
{
value.Type = AutoCSer.Net.TcpServer.ReturnType.ServerException;
Sender.AddLog(error);
}
}
public override void Call()
{
AutoCSer.Net.TcpServer.ReturnValue <_p2> value = new AutoCSer.Net.TcpServer.ReturnValue <_p2>();
if (Sender.IsSocket)
{
get(ref value);
Sender.Push(CommandIndex, _c1, ref value);
}
push(this);
}
}
private static readonly AutoCSer.Net.TcpServer.OutputInfo _c1 = new AutoCSer.Net.TcpServer.OutputInfo {
OutputParameterIndex = 2, IsBuildOutputThread = true
};
private static readonly AutoCSer.Net.TcpServer.OutputInfo _c2 = new AutoCSer.Net.TcpServer.OutputInfo {
OutputParameterIndex = 4, IsSimpleSerializeOutputParamter = true, IsBuildOutputThread = true
};
sealed class _s2 : AutoCSer.Net.TcpStaticServer.ServerCall <_s2, _p5>
{
private void get(ref AutoCSer.Net.TcpServer.ReturnValue <_p6> value)
{
try
{
string Return;
Return = AutoCSer.Web.SearchServer.SearchItem /**/.TcpStaticServer._M3(inputParameter.p0);
value.Value.Return = Return;
value.Type = AutoCSer.Net.TcpServer.ReturnType.Success;
}
catch (Exception error)
{
value.Type = AutoCSer.Net.TcpServer.ReturnType.ServerException;
Sender.AddLog(error);
}
}
public async Task <valueType[]> GetAsync(AutoCSer.Net.TcpServer.ReturnValue <int[]> identitys)
{
if (identitys.Type == AutoCSer.Net.TcpServer.ReturnType.Success)
{
return(await GetAsync(identitys.Value));
}
return(new AutoCSer.Net.TcpServer.ReturnValue <valueType[]> {
Type = identitys.Type
});
}
public override void Call()
{
AutoCSer.Net.TcpServer.ReturnValue <_p2> value = new AutoCSer.Net.TcpServer.ReturnValue <_p2>();
if (Sender.IsSocket)
{
get(ref value);
Sender.Push(CommandIndex, _c0, ref value);
}
push(this);
}
public override void RunTask()
{
AutoCSer.Net.TcpServer.ReturnValue value = new AutoCSer.Net.TcpServer.ReturnValue();
if (Sender.IsSocket)
{
get(ref value);
Sender.Push(CommandIndex, value.Type);
}
push(this);
}
public valueType[] Get(AutoCSer.Net.TcpServer.ReturnValue <int[]> identitys)
{
if (identitys.Type == AutoCSer.Net.TcpServer.ReturnType.Success)
{
return(Get(identitys.Value));
}
return(new AutoCSer.Net.TcpServer.ReturnValue <valueType[]> {
Type = identitys.Type
});
}
