예제 #1
0
        internal static bool TestCase()
        {
            using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IAsynchronous> .Create(new Asynchronous()))
            {
                if (server.IsListen)
                {
                    IAsynchronous client = AutoCSer.Net.TcpInternalServer.Emit.Client <IAsynchronous> .Create();

                    using (client as IDisposable)
                    {
                        sumWait.Reset();
                        int sum = 0;
                        client.Add(2, 3, value =>
                        {
                            if (value.Type == AutoCSer.Net.TcpServer.ReturnType.Success)
                            {
                                sum = value.Value;
                            }
                            sumWait.Set();
                            return(false);
                        });
                        sumWait.WaitOne();
                        return(sum == 2 + 3);
                    }
                }
            }
            return(false);
        }
예제 #2
0
        internal static bool TestCase()
        {
            using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IKeepCallback> .Create(new KeepCallback()))
            {
                if (server.IsListen)
                {
                    IKeepCallback client = AutoCSer.Net.TcpInternalServer.Emit.Client <IKeepCallback> .Create();

                    using (client as IDisposable)
                    {
                        sumWait.Reset();
                        int count = 4, successCount = count;
                        using (AutoCSer.Net.TcpServer.KeepCallback keepCallback =
                                   client.Add(2, 3, count, value =>
                        {
                            if (value.Type == AutoCSer.Net.TcpServer.ReturnType.Success && value.Value == 2 + 3)
                            {
                                --successCount;
                            }
                            if (--count == 0)
                            {
                                sumWait.Set();
                            }
                            return(false);
                        }))
                        {
                            sumWait.WaitOne();
                            return(successCount == 0);
                        }
                    }
                }
            }
            return(false);
        }
예제 #3
0
 /// <summary>
 /// 设置TCP服务端
 /// </summary>
 /// <param name="tcpServer">TCP服务端</param>
 public override void SetTcpServer(AutoCSer.Net.TcpInternalServer.Server tcpServer)
 {
     base.SetTcpServer(tcpServer);
     cacheFile = AutoCSer.Config.Pub.Default.CachePath + ServerName + (ServerName == tcpServer.ServerName ? null : ("_" + tcpServer.ServerName)) + ".cache";
     fromCacheFile();
     PushNotNull(this);
 }
예제 #4
0
        static void Main(string[] args)
        {
            bool            createdProcessWait;
            EventWaitHandle processWait = new EventWaitHandle(false, EventResetMode.ManualReset, "AutoCSer.TestCase.Nuget", out createdProcessWait);

            if (createdProcessWait)
            {
                Console.WriteLine(@"http://www.AutoCSer.com/TcpServer/InterfaceServer.html
");

                using (processWait)
                    using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IServer> .Create(new Server()))
                    {
                        if (server.IsListen)
                        {
                            IServer client = AutoCSer.Net.TcpInternalServer.Emit.Client <IServer> .Create();

                            using (client as IDisposable)
                            {
                                Console.WriteLine(client.Add(2, 3) == 2 + 3);
                            }
                        }
                    }
                Console.ReadKey();
            }
        }
예제 #5
0
        internal static bool TestCase()
        {
            using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IInherit> .Create(new Inherit()))
            {
                if (server.IsListen)
                {
                    IInherit client = AutoCSer.Net.TcpInternalServer.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);
                        if (sum.Type != AutoCSer.Net.TcpServer.ReturnType.Success || sum.Value != 2 + 3)
                        {
                            return(false);
                        }

                        return(true);
                    }
                }
            }
            return(false);
        }
예제 #6
0
        /// <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);
        }
예제 #7
0
        /// <summary>
        /// 设置TCP服务端
        /// </summary>
        /// <param name="tcpServer">TCP服务端</param>
        public override void SetTcpServer(AutoCSer.Net.TcpInternalServer.Server tcpServer)
        {
            base.SetTcpServer(tcpServer);
            bool isError = false;

            cacheFile = ServerName + (ServerName == tcpServer.Attribute.ServerName ? null : ("_" + tcpServer.Attribute.ServerName)) + ".cache";
            if (File.Exists(cacheFile))
            {
                try
                {
                    foreach (ProcessCopyer copyer in AutoCSer.BinarySerialize.DeSerializer.DeSerialize <ProcessCopyer[]>(File.ReadAllBytes(cacheFile)))
                    {
                        if (copyer.Guard(this))
                        {
                            guards.Add(copyer.ProcessId, copyer);
                        }
                        else
                        {
                            isError = true;
                        }
                    }
                }
                catch (Exception error)
                {
                    isError = true;
                    tcpServer.Log.Add(AutoCSer.Log.LogType.Error, error);
                }
                if (isError)
                {
                    saveCache();
                }
            }
        }
예제 #8
0
 /// <summary>
 /// 设置TCP服务端
 /// </summary>
 /// <param name="tcpServer">TCP服务端</param>
 public override void SetTcpServer(AutoCSer.Net.TcpInternalServer.Server tcpServer)
 {
     base.SetTcpServer(tcpServer);
     cacheFile = ServerName + (ServerName == tcpServer.ServerAttribute.ServerName ? null : ("_" + tcpServer.ServerAttribute.ServerName)) + ".cache";
     if (File.Exists(cacheFile))
     {
         try
         {
             foreach (ProcessCopyer copyer in AutoCSer.BinaryDeSerializer.DeSerialize <ProcessCopyer[]>(File.ReadAllBytes(cacheFile)))
             {
                 if (copyer.Guard(this))
                 {
                     guards.Add(copyer.ProcessId, copyer);
                 }
                 else
                 {
                     saveCacheLock = 1;
                 }
             }
         }
         catch (Exception error)
         {
             saveCacheLock = 1;
             tcpServer.Log.Exception(error, null, LogLevel.Exception | LogLevel.AutoCSer);
         }
         if (saveCacheLock != 0)
         {
             server.CallQueueLink.Add(new ProcessCopySaveCache(this));
         }
     }
 }
예제 #9
0
        static void Main(string[] args)
        {
            bool            createdProcessWait;
            EventWaitHandle processWait = new EventWaitHandle(false, EventResetMode.ManualReset, "AutoCSer.Example.TcpRegisterClient", out createdProcessWait);

            if (createdProcessWait)
            {
                using (processWait)
                {
                    Console.WriteLine(@"http://www.AutoCSer.com/TcpServer/Register.html
");
                    try
                    {
                        AutoCSer.Threading.ThreadPool.TinyBackground.Start(clientThread);
                        AutoCSer.Net.TcpInternalServer.Server server = null;
                        RegisterClientTestServer test = new RegisterClientTestServer();
                        do
                        {
                            AutoCSer.Net.TcpInternalServer.Server newServer = AutoCSer.Net.TcpInternalServer.Emit.Server <IRegisterClientTestServer> .Create(test, AutoCSer.MemberCopy.Copyer <AutoCSer.Net.TcpInternalServer.ServerAttribute> .MemberwiseClone(serverAttribute));

                            if (newServer.IsListen)
                            {
                                if (server != null)
                                {
                                    server.Dispose();
                                }
                                server = newServer;
                                Console.WriteLine(@"
Version:" + test.Version.toString());
                            }
                            else
                            {
                                Console.WriteLine(@"
测试服务启动失败");
                            }
                            Thread.Sleep(5000);
                            if (test.Version == 9)
                            {
                                Console.WriteLine(@"
测试结束");
                                isEnd = true;
                                if (server != null)
                                {
                                    server.Dispose();
                                }
                                Console.ReadKey();
                                return;
                            }
                            ++test.Version;
                        }while (true);
                    }
                    catch (Exception error)
                    {
                        Console.WriteLine(error.ToString());
                    }
                    Console.ReadKey();
                }
            }
        }
예제 #10
0
 /// <summary>
 /// 缓存管理
 /// </summary>
 /// <param name="slaveServer">缓存从服务</param>
 /// <param name="tcpServer">缓存服务</param>
 internal CacheManager(SlaveServer slaveServer, AutoCSer.Net.TcpInternalServer.Server tcpServer)
 {
     shortPaths  = new ShortPathItem[slaveServer.Config.GetShortPathCount];
     loadBuffer  = new Buffer();
     SlaveServer = slaveServer;
     TcpServer   = tcpServer;
     Config      = slaveServer.Config;
     CanWrite    = false;
 }
예제 #11
0
 internal static bool TestCase()
 {
     using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IServer> .Create(new Server()))
     {
         if (server.IsListen)
         {
             return(testCase(AutoCSer.Net.TcpInternalServer.Emit.Client <IServer> .Create()));
         }
     }
     return(false);
 }
예제 #12
0
 /// <summary>
 /// 设置TCP服务端
 /// </summary>
 /// <param name="tcpServer">TCP服务端</param>
 public override void SetTcpServer(AutoCSer.Net.TcpInternalServer.Server tcpServer)
 {
     base.SetTcpServer(tcpServer);
     cacheFileName = AutoCSer.Config.Pub.Default.CachePath + ServerName + (ServerName == tcpServer.Attribute.ServerName ? null : ("_" + tcpServer.Attribute.ServerName)) + ".cache";
     FileWatcher   = new AutoCSer.IO.CreateFlieTimeoutWatcher(ProcessCopyer.Config.CheckTimeoutSeconds, this, AutoCSer.IO.CreateFlieTimeoutType.HttpServerRegister, tcpServer.Log);
     if (!AutoCSer.Config.Pub.Default.IsService && ProcessCopyer.Config.WatcherPath != null)
     {
         try
         {
             FileWatcher.Add(ProcessCopyer.Config.WatcherPath);
         }
         catch (Exception error)
         {
             tcpServer.Log.Add(AutoCSer.Log.LogType.Error, error, ProcessCopyer.Config.WatcherPath);
         }
     }
     try
     {
         if (System.IO.File.Exists(cacheFileName))
         {
             Cache[] cache = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Cache[]>(System.IO.File.ReadAllBytes(cacheFileName));
             isLoadCache = true;
             if (OnLoadCacheDomain != null)
             {
                 OnLoadCacheDomain();
             }
             for (int index = cache.Length; index != 0;)
             {
                 try
                 {
                     start(ref cache[--index]);
                 }
                 catch (Exception error)
                 {
                     tcpServer.Log.Add(AutoCSer.Log.LogType.Error, error);
                 }
             }
         }
     }
     catch (Exception error)
     {
         tcpServer.Log.Add(AutoCSer.Log.LogType.Error, error);
     }
     if (isLoadCache)
     {
         isLoadCache = false;
     }
     else if (OnLoadCacheDomain != null)
     {
         OnLoadCacheDomain();
     }
 }
예제 #13
0
        internal static bool TestCase()
        {
            using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IServerAsynchronous> .Create(new ServerAsynchronous()))
            {
                if (server.IsListen)
                {
                    IServerAsynchronousClient client = AutoCSer.Net.TcpInternalServer.Emit.Client <IServerAsynchronousClient> .Create();

                    using (client as IDisposable)
                    {
                        AutoCSer.Net.TcpServer.ReturnValue <int> sum = client.Add(2, 3);
                        return(sum.Type == Net.TcpServer.ReturnType.Success && sum.Value == 2 + 3);
                    }
                }
            }
            return(false);
        }
예제 #14
0
        /// <summary>
        /// 断线重连测试
        /// </summary>
        internal static void ConnectionTest()
        {
            IServer client = AutoCSer.Net.TcpInternalServer.Emit.Client <IServer> .Create();

            using (client as IDisposable)
            {
                long value;
                AutoCSer.Net.TcpServer.ReturnType returnType;
                do
                {
                    using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IServer> .Create(new Server()))
                    {
                        if (server.IsListen)
                        {
                            value      = LongValue;
                            returnType = client.IncLong().Type;
                            if (returnType == AutoCSer.Net.TcpServer.ReturnType.Success && LongValue == value + 1)
                            {
                                Console.Write('.');
                            }
                            else
                            {
                                Console.WriteLine(@"
" + returnType.ToString());
                            }
                        }
                        else
                        {
                            Console.WriteLine(@"
Server is not listen");
                        }
                    }
                    returnType = client.IncLong().Type;
                    if (returnType == AutoCSer.Net.TcpServer.ReturnType.ClientDisposed)
                    {
                        Console.Write('.');
                    }
                    else
                    {
                        Console.WriteLine(@"
" + returnType.ToString());
                    }
                }while (true);
            }
        }
예제 #15
0
        static void Main(string[] args)
        {
            bool            createdProcessWait;
            EventWaitHandle processWait = new EventWaitHandle(false, EventResetMode.ManualReset, "AutoCSer.TestCase.TcpInternalServerPerformance.Emit", out createdProcessWait);

            if (createdProcessWait)
            {
                Console.WriteLine(@"http://www.AutoCSer.com/TcpServer/InterfaceServer.html
");
                using (processWait)
                    using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IServer> .Create(new InternalServer()))
                    {
                        if (server.IsListen)
                        {
#if DEBUG
                            FileInfo clientFile = new FileInfo(Path.Combine(AutoCSer.PubPath.ApplicationPath, @"..\..\..\TcpClientPerformance\bin\Debug\AutoCSer.TestCase.TcpInternalClientPerformance.Emit.exe".pathSeparator()));
#else
                            FileInfo clientFile = new FileInfo(Path.Combine(AutoCSer.PubPath.ApplicationPath, @"..\..\..\TcpClientPerformance\bin\Release\AutoCSer.TestCase.TcpInternalClientPerformance.Emit.exe".pathSeparator()));
#endif
                            if (!clientFile.Exists)
                            {
                                clientFile = new FileInfo(Path.Combine(AutoCSer.PubPath.ApplicationPath, @"AutoCSer.TestCase.TcpInternalClientPerformance.Emit.exe"));
                            }
                            if (clientFile.Exists)
                            {
                                Process.Start(clientFile.FullName);
                            }
                            else
                            {
                                Console.WriteLine("未找到 TCP 内部服务性能测试服务 客户端程序");
                            }
                            Console.WriteLine("Press quit to exit.");
                            while (Console.ReadLine() != "quit")
                            {
                                ;
                            }
                        }
                        else
                        {
                            Console.WriteLine("TCP 内部服务性能测试服务 启动失败");
                            Console.ReadKey();
                        }
                    }
            }
        }
예제 #16
0
        internal static bool TestCase()
        {
            using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IRefOut> .Create(new RefOut()))
            {
                if (server.IsListen)
                {
                    IRefOut client = AutoCSer.Net.TcpInternalServer.Emit.Client <IRefOut> .Create();

                    using (client as IDisposable)
                    {
                        int right = 3, product;
                        AutoCSer.Net.TcpServer.ReturnValue <int> sum = client.Add(2, ref right, out product);
                        return(sum.Type == AutoCSer.Net.TcpServer.ReturnType.Success && sum.Value == 2 + 3 && right == (3 << 1) && product == 2 * 3);
                    }
                }
            }
            return(false);
        }
예제 #17
0
        internal static bool TestCase()
        {
            using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <ISendOnly> .Create(new SendOnly()))
            {
                if (server.IsListen)
                {
                    ISendOnly client = AutoCSer.Net.TcpInternalServer.Emit.Client <ISendOnly> .Create();

                    using (client as IDisposable)
                    {
                        sumWait.Reset();
                        sum = 0;
                        client.SetSum(2, 3);
                        sumWait.WaitOne();
                        return(sum == 2 + 3);
                    }
                }
            }
            return(false);
        }
예제 #18
0
        static void Main(string[] args)
        {
#if DotNetStandard
            Console.WriteLine("WARN : Linux .NET Core not support name EventWaitHandle");
#else
            bool            createdProcessWait;
            EventWaitHandle processWait = new EventWaitHandle(false, EventResetMode.ManualReset, "AutoCSer.TestCase.TcpInternalServerPerformance.Emit", out createdProcessWait);
            if (createdProcessWait)
            {
                using (processWait)
                {
#endif
            Console.WriteLine(@"http://www.AutoCSer.com/TcpServer/InterfaceServer.html
");
            using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IServer> .Create(new InternalServer()))
            {
                if (server.IsListen)
                {
                    if (!startProcess("TcpClientPerformance", "AutoCSer.TestCase.TcpInternalClientPerformance.Emit"))
                    {
                        Console.WriteLine("未找到 TCP 内部服务性能测试服务 客户端程序");
                    }
                    Console.WriteLine("Press quit to exit.");
                    while (Console.ReadLine() != "quit")
                    {
                        ;
                    }
                }
                else
                {
                    Console.WriteLine("TCP 内部服务性能测试服务 启动失败");
                    Console.ReadKey();
                }
            }
#if !DotNetStandard
        }
    }
#endif
        }
예제 #19
0
 /// <summary>
 /// 缓存管理
 /// </summary>
 /// <param name="config">缓存服务配置</param>
 /// <param name="tcpServer">缓存服务</param>
 internal CacheManager(MasterServerConfig config, AutoCSer.Net.TcpInternalServer.Server tcpServer)
 {
     Config     = config;
     TcpServer  = tcpServer;
     tcpQueue   = tcpServer.CallQueue;
     shortPaths = new ShortPathItem[config.GetShortPathCount];
     if (config.IsFile)
     {
         disposeHandle = Dispose;
         IsFile        = true;
         File          = new FileStreamWriter(this, config);
         foreach (Cache.MessageQueue.Node messageQueue in LoadMessageQueues)
         {
             messageQueue.Start();
         }
         LoadMessageQueues.SetNull();
         IsLoaded = CanWrite = true;
         AutoCSer.DomainUnload.Unloader.Add(disposeHandle, DomainUnload.Type.Action);
     }
     else
     {
         IsLoaded = CanWrite = true;
     }
 }
예제 #20
0
        static void Main(string[] args)
        {
#if DotNetStandard
            Console.WriteLine("WARN : Linux .NET Core not support name EventWaitHandle");
#else
            bool            createdProcessWait;
            EventWaitHandle processWait = new EventWaitHandle(false, EventResetMode.ManualReset, "AutoCSer.Example.TcpRegisterClient", out createdProcessWait);
            if (createdProcessWait)
            {
                using (processWait)
                {
#endif
            Console.WriteLine(@"http://www.AutoCSer.com/TcpServer/Register.html
");
            try
            {
                AutoCSer.Threading.ThreadPool.TinyBackground.Start(clientThread);
                AutoCSer.Net.TcpInternalServer.Server server = null;
                RegisterClientTestServer test = new RegisterClientTestServer();
                do
                {
                    AutoCSer.Net.TcpInternalServer.ServerAttribute attribute = AutoCSer.MemberCopy.Copyer <AutoCSer.Net.TcpInternalServer.ServerAttribute> .MemberwiseClone(serverAttribute);

                    attribute.Port = 30000 + test.Version;
                    AutoCSer.Example.TcpRegisterClient.RegisterClientTestServer.TcpInternalServer newServer = new RegisterClientTestServer.TcpInternalServer(attribute, null, test);
                    if (newServer.IsListen)
                    {
                        if (server != null)
                        {
                            server.Dispose();
                        }
                        server = newServer;
                        Console.WriteLine(@"
Version:" + test.Version.toString());
                    }
                    else
                    {
                        Console.WriteLine(@"
测试服务启动失败");
                    }
                    Thread.Sleep(5000);
                    if (test.Version == 9)
                    {
                        Console.WriteLine(@"
测试结束");
                        isEnd = true;
                        if (server != null)
                        {
                            server.Dispose();
                        }
                        Console.ReadKey();
                        return;
                    }
                    test = new RegisterClientTestServer {
                        Version = test.Version + 1
                    };
                }while (true);
            }
            catch (Exception error)
            {
                Console.WriteLine(error.ToString());
            }
            Console.ReadKey();
#if !DotNetStandard
        }
    }
#endif
        }
예제 #21
0
        /// <summary>
        /// 远程表达式测试
        /// </summary>
        /// <returns></returns>
        internal static bool TestCase()
        {
            using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IRefOut> .Create(new RefOut()))
            {
                if (server.IsListen)
                {
                    using (AutoCSer.Net.TcpInternalServer.Emit.MethodClient client = AutoCSer.Net.TcpInternalServer.Emit.Client <IRefOut> .Create() as AutoCSer.Net.TcpInternalServer.Emit.MethodClient)
                    {
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticField).Value.Value != 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticProperty).Value.Value != 2)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(3)).Value.Value != 3)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticField.Value).Value != 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticProperty.Value).Value != 2)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(3).Value).Value != 3)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(4)[3]).Value != 4 + 3)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(4).GetNextNode(2)).Value.Value != 4 + 2)
                        {
                            return(false);
                        }

                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticField.NextNode).Value.Value != 1 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticProperty.NextNode).Value.Value != 2 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(3).NextNode).Value.Value != 3 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticField.NextNode.Value).Value != 1 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticProperty.NextNode.Value).Value != 2 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(3).NextNode.Value).Value != 3 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(4).NextNode[3]).Value != 4 + 1 - 3)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(4).NextNode.GetLastNode(2)).Value.Value != 4 + 1 - 2)
                        {
                            return(false);
                        }

                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticField.NextNode.LastNode).Value.Value != 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticProperty.NextNode.LastNode).Value.Value != 2)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(3).NextNode.LastNode).Value.Value != 3)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticField.NextNode.LastNode.Value).Value != 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticProperty.NextNode.LastNode.Value).Value != 2)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(3).NextNode.LastNode.Value).Value != 3)
                        {
                            return(false);
                        }

                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticField.NextNode.LastNode.NextNode).Value.Value != 1 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticProperty.NextNode.LastNode.NextNode).Value.Value != 2 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(3).NextNode.LastNode.NextNode).Value.Value != 3 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticField.NextNode.LastNode.NextNode.Value).Value != 1 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticProperty.NextNode.LastNode.NextNode.Value).Value != 2 + 1)
                        {
                            return(false);
                        }
                        if (client._TcpClient_.GetRemoteExpression(RemoteExpression.StaticMethod(3).NextNode.LastNode.NextNode.Value).Value != 3 + 1)
                        {
                            return(false);
                        }

                        return(true);
                    }
                }
            }
            return(false);
        }
예제 #22
0
        static void Main(string[] args)
        {
#if DotNetStandard
            Console.WriteLine("WARN : Linux .NET Core not support name EventWaitHandle");
#else
            bool            createdProcessWait;
            EventWaitHandle processWait = new EventWaitHandle(false, EventResetMode.ManualReset, "AutoCSer.TestCase.TcpInternalServerPerformance.Emit", out createdProcessWait);
            if (createdProcessWait)
            {
                using (processWait)
                {
#endif
            Console.WriteLine(@"http://www.AutoCSer.com/TcpServer/InterfaceServer.html
");
            using (AutoCSer.Net.TcpInternalServer.Server server = AutoCSer.Net.TcpInternalServer.Emit.Server <IServer> .Create(new InternalServer()))
            {
                if (server.IsListen)
                {
#if DotNetStandard
#if DEBUG
                    FileInfo clientFile = new FileInfo(Path.Combine(AutoCSer.PubPath.ApplicationPath, @"..\..\..\..\TcpClientPerformance\bin\Debug\netcoreapp2.0\AutoCSer.TestCase.TcpInternalClientPerformance.Emit.dll".pathSeparator()));
#else
                    FileInfo clientFile = new FileInfo(Path.Combine(AutoCSer.PubPath.ApplicationPath, @"..\..\..\..\TcpClientPerformance\bin\Release\netcoreapp2.0\AutoCSer.TestCase.TcpInternalClientPerformance.Emit.dll".pathSeparator()));
#endif
                    if (!clientFile.Exists)
                    {
                        clientFile = new FileInfo(Path.Combine(AutoCSer.PubPath.ApplicationPath, @"AutoCSer.TestCase.TcpInternalClientPerformance.Emit.dll"));
                    }
                    if (clientFile.Exists)
                    {
                        ProcessStartInfo process = new ProcessStartInfo("dotnet", clientFile.FullName);
                        process.UseShellExecute = true;
                        Process.Start(process);
                    }
#else
#if DEBUG
                    FileInfo clientFile = new FileInfo(Path.Combine(AutoCSer.PubPath.ApplicationPath, @"..\..\..\TcpClientPerformance\bin\Debug\AutoCSer.TestCase.TcpInternalClientPerformance.Emit.exe".pathSeparator()));
#else
                    FileInfo clientFile = new FileInfo(Path.Combine(AutoCSer.PubPath.ApplicationPath, @"..\..\..\TcpClientPerformance\bin\Release\AutoCSer.TestCase.TcpInternalClientPerformance.Emit.exe".pathSeparator()));
#endif
                    if (!clientFile.Exists)
                    {
                        clientFile = new FileInfo(Path.Combine(AutoCSer.PubPath.ApplicationPath, @"AutoCSer.TestCase.TcpInternalClientPerformance.Emit.exe"));
                    }
                    if (clientFile.Exists)
                    {
                        Process.Start(clientFile.FullName);
                    }
#endif
                    else
                    {
                        Console.WriteLine("未找到 TCP 内部服务性能测试服务 客户端程序");
                    }
                    Console.WriteLine("Press quit to exit.");
                    while (Console.ReadLine() != "quit")
                    {
                        ;
                    }
                }
                else
                {
                    Console.WriteLine("TCP 内部服务性能测试服务 启动失败");
                    Console.ReadKey();
                }
            }
#if !DotNetStandard
        }
    }
#endif
        }
예제 #23
0
 /// <summary>
 /// 设置TCP服务端
 /// </summary>
 /// <param name="tcpServer">TCP服务端</param>
 public override void SetTcpServer(AutoCSer.Net.TcpInternalServer.Server tcpServer)
 {
     base.SetTcpServer(tcpServer);
     Cache = new CacheManager(Config, tcpServer);
 }
예제 #24
0
 /// <summary>
 /// 设置TCP服务端
 /// </summary>
 /// <param name="tcpServer">TCP服务端</param>
 public override void SetTcpServer(AutoCSer.Net.TcpInternalServer.Server tcpServer)
 {
     base.SetTcpServer(tcpServer);
     checkSocketVersion = Config.IsMasterCacheServer ? masterClient._TcpClient_.CreateCheckSocketVersion(onClientSocket) : slaveClient._TcpClient_.CreateCheckSocketVersion(onClientSocket);
 }