示例#1
0
        private static void BatchSendRequestAdd(ITcpClientServer.ITcpEventClient client)
        {
            int v1 = new Random().Next(3, 9);

            int[] v2 = new int[] { 1, 2, 3, 4, 5 };
            foreach (int i in v2)
            {
                Task.Factory.StartNew(() =>
                {
                    try
                    {
                        log4j.Info(string.Format("RequestAdd {0} {1}", v1, i));
                        //Task<Data.ResponseAdd> responseAdd = client.RequestAddAsync(v1, i);
                        //log4j.Info(string.Format("ResponseAdd {0} + {1} = {2}", v1, i, responseAdd.Result.Result));

                        ResponseAdd response = client.RequestAdd(v1, i);
                        log4j.Info(string.Format("responseAdd: {0} + {1} = {2}", v1, i, response.Result));
                    }
                    catch (Exception ex)
                    {
                        log4j.Info(string.Format("RequestAdd {0} {1} {2}", v1, i, ex.Message));
                    }
                });
            }
        }
示例#2
0
        public ResponseAdd RequestAdd(int timeOutMilliSec, params int[] param)
        {
            RequestAdd requestAdd = new RequestAdd {
                UUID = Guid.NewGuid().ToString()
            };

            foreach (int p in param)
            {
                requestAdd.Param.Add(p);
            }

            // set a timeout on this call to server!
            // if we do not hv this timeout, calling this RequestAdd method will forever waiting if server never response!
            TaskCompletionSource <ResponseAdd> tcs = new TaskCompletionSource <ResponseAdd>();

            //CancellationTokenSource ct = new CancellationTokenSource(timeOutMilliSec);
            // package TaskParallelLibrary CancellationTokenSource only hv empty constructor!!
            CancellationTokenSource ct = new CancellationTokenSource();

            ResponseAddHandler rah = ((rpAdd) =>
            {
                // only want the response UUID which is same as what we send
                if (rpAdd.UUID == requestAdd.UUID)
                {
                    tcs.TrySetResult(rpAdd);
                }
            });

            // when timeout occur, set Exception to TaskCompletionSource
            // also remove the callback from eventhandler
            ct.Token.Register(() =>
            {
                OnResponseAdd -= rah;
                tcs.TrySetException(new TimeoutException("TimeOut " + timeOutMilliSec));
            }, useSynchronizationContext: false);


            // use Rackspace.Threading.CancellationTokenSourceExtensions CancelAfter
            ct.CancelAfter(TimeSpan.FromMilliseconds(timeOutMilliSec));

            OnResponseAdd += rah;   //hook to the eventHandler
            //string sendCmd = "RequestAdd " + Newtonsoft.Json.JsonConvert.SerializeObject(requestAdd) + "\r\n";
            string sendCmd = Cmd.TcsCommand.RequestAdd.ToString() + " " + Newtonsoft.Json.JsonConvert.SerializeObject(requestAdd) + "\r\n";

            base.Send(Encoding.UTF8.GetBytes(sendCmd));
            tcs.Task.Wait();
            ResponseAdd responseAdd = tcs.Task.Result;

            OnResponseAdd -= rah;   //after received our response, unhook it. we only expecting 1 response.

            return(responseAdd);
        }
示例#3
0
        /// <summary>
        /// Send command RequestAdd to server
        /// Receive a Data.ResponseAdd object
        /// - async method
        /// - will throw Exception "TimeOut"
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public async Task <ResponseAdd> RequestAddAsync(params int[] param)
        {
            RequestAdd requestAdd = new RequestAdd {
                UUID = Guid.NewGuid().ToString()
            };

            foreach (int p in param)
            {
                requestAdd.Param.Add(p);
            }

            // set a timeout on this call to server!
            TaskCompletionSource <ResponseAdd> tcs = new TaskCompletionSource <ResponseAdd>();
            const int timeOuts         = 10000; //miliseconds
            CancellationTokenSource ct = new CancellationTokenSource(timeOuts);

            ResponseAddHandler rah = ((rpAdd) =>
            {
                // only want the response UUID which is same as what we send
                if (rpAdd.UUID == requestAdd.UUID)
                {
                    tcs.TrySetResult(rpAdd);
                }
            });

            // when timeout occur, set Exception to TaskCompletionSource
            // also remove the callback from eventhandler
            ct.Token.Register(() =>
            {
                OnResponseAdd -= rah;
                tcs.TrySetException(new TimeoutException("TimeOut " + timeOuts));
            }, useSynchronizationContext: false);

            OnResponseAdd += rah;   //hook to the eventHandler
            //string sendCmd = "RequestAdd " + Newtonsoft.Json.JsonConvert.SerializeObject(requestAdd) + "\r\n";
            string sendCmd = Cmd.TcsCommand.RequestAdd.ToString() + " " + Newtonsoft.Json.JsonConvert.SerializeObject(requestAdd) + "\r\n";

            base.Send(Encoding.UTF8.GetBytes(sendCmd));

            ResponseAdd responseAdd = await tcs.Task;

            OnResponseAdd -= rah;   //after received our response, unhook it. we only expecting 1 response.

            return(responseAdd);
        }
示例#4
0
 /// <summary>
 /// this will call by Command Class ResponseAdd
 /// </summary>
 /// <param name="responseAdd"></param>
 internal void PushToResponseAddHandler(ResponseAdd responseAdd)
 {
     //OnResponseAdd?.Invoke(responseAdd);
     OnResponseAdd?.BeginInvoke(responseAdd, (iar) =>
     {
         log4j.Info("endInvoke");
         var ar           = (System.Runtime.Remoting.Messaging.AsyncResult)iar;
         var invokeMethod = (ResponseAddHandler)ar.AsyncDelegate;
         try
         {
             invokeMethod.EndInvoke(iar);
         }
         catch (Exception ex)
         {
             log4j.Error(invokeMethod.ToString(), ex);
         }
     }, null);
 }
示例#5
0
        public async Task <IActionResult> GetUsers([FromQuery] UserParams userParams)
        {
            ResponseAdd re = new ResponseAdd();

            var currentLoggedInUser = await datingRepository.GetUser(int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value));

            userParams.Id = currentLoggedInUser.Id;

            if (!string.IsNullOrEmpty(currentLoggedInUser.Gender) &&
                string.IsNullOrEmpty(userParams.Gender) &&
                userParams.Likees == false &&
                userParams.Likers == false)
            {
                userParams.Gender = currentLoggedInUser.Gender == "male" ? "female" : "male";
            }

            PagedList <User> users = await datingRepository.GetUsers(userParams);

            Response.AddPaginationHeader(users.PageNumber, users.PageSize, users.TotalCount, users.TotalPages);
            var usersToReturn = mapper.Map <IEnumerable <UserList> >(users);

            re.ResponseBody = usersToReturn;
            return(Ok(re));
        }
示例#6
0
 /// <summary>
 /// this will call by Command Class ResponseAdd
 /// </summary>
 /// <param name="responseAdd"></param>
 internal void PushToResponseAddHandler(ResponseAdd responseAdd)
 {
     OnResponseAdd?.Invoke(responseAdd);
 }
示例#7
0
        static void Main(string[] args)
        {
            System.Net.IPEndPoint            endpoint = new IPEndPoint(new IPAddress(new byte[] { 127, 0, 0, 1 }), 2012);
            ITcpClientServer.ITcpEventClient client   = new SPTcpClient(endpoint)
            {
                TimeOutMilliSec = 8000
            };


            client.OnResponseEcho += new ITcpClientServer.ResponseEchoHandler(message =>
            {
                log4j.Info("Received echo: " + message);
            });



            client.Start();

            string cmd = "";

            while (cmd != "q")
            {
                if (cmd == "1")
                {
                    int a = 4;
                    int b = 4;
                    try
                    {
                        //Task<Data.ResponseAdd> response = client.RequestAddAsync(a, b);
                        //log4j.Info(string.Format("responseAdd: {0} + {1} = {2}", a, b, response.Result.Result));
                        Task t1 = Task.Factory.StartNew(() =>
                        {
                            ResponseAdd response = client.RequestAdd(a, b);
                            log4j.Info(string.Format("responseAdd: {0} + {1} = {2}", a, b, response.Result));
                        });
                        //client.Send(Encoding.UTF8.GetBytes("RequestEcho abcdefg\r\n"));
                        //client.Send(Encoding.UTF8.GetBytes(Data.Cmd.MyCommand.RequestEcho.ToString() + " abcdefg\r\n"));
                        client.RequestEcho("aaasslslslsl");
                        t1.Wait();
                    }
                    catch (AggregateException ae)
                    {
                        log4j.Info("catch aggregateException", ae);
                        //ae.Handle((x) =>
                        //{
                        //    Console.WriteLine(x.GetType().ToString());
                        //    if(x is TimeoutException)
                        //    {
                        //        log4j.Info("TimeOut", x);
                        //        return true;
                        //    }

                        //    return true;
                        //});
                        foreach (var e in ae.InnerExceptions)
                        {
                            Console.WriteLine(e.GetType().ToString());
                            if (e is TimeoutException)
                            {
                                log4j.Info("TimeOut", e);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        log4j.Info("error", ex);
                    }
                }
                else if (cmd == "3")
                {
                    BatchSendRequestAdd(client);
                }
                //else if (cmd != "")
                //{
                //    // Server Command
                //    // RequestEcho text
                //    byte[] data = Encoding.UTF8.GetBytes(cmd + "\r\n");
                //    //client.Send(data, 0, data.Length);
                //    log4j.Info("sending raw command: " + cmd);
                //    client.Send(data);
                //}
                cmd = Console.ReadLine();
            }
            client.Stop();
        }