/// <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 }); }