public Task<Response> SendAsync(object data, RequestType type)
        {
            Request req = new Request()
            {
                Data = data,
                RequestType = type
            };

            return Task.Run(() =>
            {
                try
                {
                    this.Formatter.Serialize(this.SocketStream, req);
                    var response = this.Formatter.Deserialize(this.SocketStream) as Response;
                    return response;
                }
                catch
                {
                    return new Response()
                    {
                        ResponseType = ResponseType.Error,
                        Message = "Server not responding. Try later."
                    };
                }
            });
        }

        public static WebRequest createGetRequest(RequestType requestType, Authentication authentication, int? id, int? type, bool? unread, int? fromId)
        {
            HttpRequestAttr requestAttrs = (HttpRequestAttr)requestType.GetAttr();
            WebRequest request;
            string url = requestAttrs.URL;
            if (id.HasValue)
            {
                url += ("/" + id);
            }

            url += "?username=" + authentication.Username + "&secretKey=" + authentication.SecretKey;

            if (type.HasValue)
            {
                url += "&type=" + type.Value;
            }

            if (unread.HasValue)
            {
                url += "&unread=" + unread.Value;
            }

            if (fromId.HasValue)
            {
                url += "&fromId=" + fromId.Value;
            }

            request = WebRequest.Create(url);
            request.Method = requestAttrs.Method;
            request.Timeout = CONNECTION_TIMEOUT;

            return request;
        }

        protected async Task<string> ExecuteRequestAsync(string url, RequestType type, Dictionary<string, string> @params)
        {
            string result;

            using (var client = new HttpClient())
            {
                if (type == RequestType.POST)
                {
                    var content = new FormUrlEncodedContent(@params);
                    var response = await client.PostAsync(url, content);
                    result = await response.Content.ReadAsStringAsync();
                }
                else
                {
                    // append guid to prevent http requests caching 
                    StringBuilder args = new StringBuilder("?nocache=" + Guid.NewGuid() + "&");

                    // build params string
                    foreach (var pair in @params)
                    {
                        args.AppendFormat("{0}={1}&", pair.Key, pair.Value);
                    }

                    // append params to url
                    url = url + args;

                    // remove last '&' symbol and execute request
                    result = await client.GetStringAsync(url.Remove(url.Length - 1));
                }

            }

            return result;
        }

        public static void ConflictRequest(RequestType firstRequest, RequestType secondRequest)
        {
            // For RequestType.Lease, only containg one request (Create with Lease context)
            // for the second client, so DeleteAfter is not applicable.
            Condition.IfThen(firstRequest == RequestType.UncommitedDelete, secondRequest != RequestType.Lease);

            // DeleteAfter is the same as Delete for second request
            Condition.IsTrue(secondRequest != RequestType.UncommitedDelete);
            switch (firstRequest)
            {
                case RequestType.ExclusiveLock:
                    State = FileState.Locked;
                    break;
                case RequestType.Lease:
                    State = FileState.LeaseGranted;
                    break;
                case RequestType.UncommitedDelete:
                    State = FileState.ToBeDeleted;
                    break;
                case RequestType.Delete:
                    State = FileState.Deleted;
                    break;
                // No state changed
                case RequestType.Write:
                case RequestType.Read:
                default:
                    break;
            }

            SecondRequest = secondRequest;
        }

 public RequestBuilder(RequestType requestType, string action)
 {
     this.RequestType = requestType;
     this.Action = action;
     this._urlSegments = new List<string>();
     this._queryStringParameters = new Dictionary<string, string>();
 }

 private Command C(string path, RequestType requestType = RequestType.Get)
 {
     return Cmd(path, requestType)
         .WithParameter(@"login", _login)
         .WithParameter(@"apiKey", _apiKey)
         .WithParameter(@"format", @"json");
 }

        public static RequestReply Request(RequestType type, string title, string message, List<string> choices, string default_choice)
        {
            RequestReply request = new RequestReply();

            if(type== RequestType.Choice&&choices==null)
                throw new MException("NeedInfo Error","A choice was requested, but no options provided",true);

            RequestEventArgs e = new RequestEventArgs(type,title,message,choices,default_choice,request);

            ICommunicationReceiver receiver = getReceiver();

            if(receiver==null) {
                request.cancelled =true;
                return request;
            }

            if(receiver.context!=null) {
                receiver.context.Post(new SendOrPostCallback(delegate(object state) {
                    RequestEventHandler handler = receiver.requestInformation;
                    if(handler!=null) {
                        handler(e);
                    }
                }),null);
            } else {
                receiver.requestInformation(e);
            }

            waitForResponse(e);

            if(e.response== ResponseType.Cancel||e.response== ResponseType.No)
                e.result.cancelled = true;

            return e.result;
        }

 private InstrumentationToken(RequestType type, ExecutionFlags executionFlags, string cql)
 {
     Id = Guid.NewGuid();
     Type = type;
     ExecutionFlags = executionFlags;
     Cql = cql;
 }

        /// <summary>
        /// Excute request async method operator [httpclient version]
        /// </summary>
        /// <param name="requestUrl">Request Url</param>
        /// <param name="requestType">Request Type</param>
        /// <param name="postArguemntList">Post Argument List</param>
        public void ExcuteAsyncRequest(string requestUrl, RequestType requestType,List<KeyValuePair<string,object>> postArguemntList=null)
        {
            HttpClient requestClient = new HttpClient();
            if (requestType == RequestType.GET)
                requestClient.GetAsync(requestUrl).ContinueWith((postback) =>
                {
                    postback.Result.EnsureSuccessStatusCode();
                    if (AsyncResponseComplated != null)
                        AsyncResponseComplated(postback.Result.Content.ReadAsStringAsync().Result, null);

                });
            else if (requestType == RequestType.POST)
            {     
                HttpContent content=null;
                if (postArguemntList != null)
                {
                    List<KeyValuePair<string, string>> argumentList = null;
                    postArguemntList.ForEach(queryArgument => { argumentList.Add(new KeyValuePair<string,string>(queryArgument.Key,queryArgument.Value.ToString())); });
                    content = new FormUrlEncodedContent(argumentList);
                }
                requestClient.PostAsync(requestUrl, content).ContinueWith((postback) =>
                {
                    postback.Result.EnsureSuccessStatusCode();
                    if (AsyncResponseComplated != null)
                        AsyncResponseComplated(postback.Result.Content.ReadAsStringAsync().Result, null);
                });
            }
        }

        public static object Service(this Uri url, RequestType requestType, ResponseType responseType, out int resultCode, string outputFilename, IDictionary<string, string> formData) {
            object result = null;
            resultCode = -1;

            var webRequest = (HttpWebRequest)WebRequest.Create(url);
            webRequest.Proxy = GetProxy();

            webRequest.CookieContainer = Cookies.GetCookieContainer();

            switch (requestType) {
                case RequestType.POST:
                    webRequest.Method = "POST";
                    webRequest.ContentType = "application/x-www-form-urlencoded";

                    var encodedFormData = Encoding.UTF8.GetBytes(GetFormData(formData).ToString());
                    using (var requestStream = webRequest.GetRequestStream()) {
                        requestStream.Write(encodedFormData, 0, encodedFormData.Length);
                    }
                    break;
                case RequestType.GET:
                    webRequest.Method = "GET";
                    if (formData != null) {
                        var ub = new UriBuilder(url) {
                            Query = GetFormData(formData).ToString()
                        };
                        url = ub.Uri;
                    }
                    break;
            }

            try {
                if (credentialCache != null) {
                    webRequest.Credentials = credentialCache;
                    webRequest.PreAuthenticate = true;
                }
                var webResponse = webRequest.GetResponse();

                if (!KeepCookiesClean) {
                    Cookies.AddCookies(webRequest.CookieContainer.GetCookies(webResponse.ResponseUri));
                }

                switch (responseType) {
                    case ResponseType.String:
                        result = GetStringResponse(webResponse);
                        resultCode = 200;
                        break;
                    case ResponseType.Binary:
                        result = GetBinaryResponse(webResponse);
                        resultCode = 200;
                        break;
                    case ResponseType.File:
                        result = GetBinaryFileResponse(webResponse, outputFilename);
                        resultCode = 200;
                        break;
                }
            } catch {
                resultCode = 0;
            }
            return result;
        }

 /// <summary>
 /// Creates the request of the specified type.
 /// </summary>
 /// <param name="requestType">Type of the request.</param>
 /// <param name="args">The args needed to create the request.</param>
 /// <returns>the request instance</returns>
 public IRequest CreateRequest(RequestType requestType, object[] args)
 {
     string requestName = GetRequestClassNameFromType(requestType);
      Type type = Type.GetType(requestName);
      IRequest request = (IRequest) Activator.CreateInstance(type, args);
      return request;
 }

 public _0x34GetPlayerStatus(int Serial,RequestType reqtype)
     : base(0x34)
 {
     Data.WriteUInt(0xedededed);
     Data.WriteBit((byte)reqtype);
     Data.WriteInt(Serial);
 }

 public RequestResourceContext(IAdapter adapter, IAdaptee adaptee,
     RequestType resource)
 {
     Adaptee = adaptee;
     Adapter = adapter;
     ReqType = resource;
 }

        public Request(string clientAddress, RequestType type, string path, double version, Dictionary<string, string> headers)
        {
            ClientAddress = clientAddress;
            Type = type;
            Path = path;
            Version = version;
            Headers = headers;
            string lengthString;
            if (Headers.TryGetValue("Content-Length", out lengthString))
            {
                try
                {
                    ContentLength = Convert.ToInt32(lengthString);
                }
                catch (FormatException)
                {
                    throw new ClientException("Invalid content length specified");
                }
            }
            else
                ContentLength = null;

            Headers.TryGetValue("X-Real-IP", out ClientAddress);

            Content = new Dictionary<string, string>();

            //Arguments are null until set by a non-default Handler
            Arguments = null;

            RequestHandler = null;
        }

 public ChangeRequest(string path, string target, RequestType requestType, ItemType itemType)
 {
     this.item = new ItemSpec(path, RecursionType.None);
     this.target = target;
     this.requestType = requestType;
     this.itemType = itemType;
 }

 //REQUEST
 public NetCommand(RequestType request, int session)
 {
     Type = CommandType.REQUEST;
     Session = session;
     Timestamp = Helper.Now;
     Request = request;
 }

		public DeckCloudFileResponse(DataSet dset, RequestType requestType)
		{
			// Get the only row in the cloud_file table.
			DataRow deckCloudFile = dset.Tables["cloud_file"].AsEnumerable().Single();

			// Get the file data ID.
			FileDataId = deckCloudFile.Field<long>("id");

			if (requestType != RequestType.FinishChunking)
			{
				// Get the only row in the multipart_upload table.
				DataRow deckMultipartUpload = dset.Tables["multipart_upload"].AsEnumerable().Single();
				
				// Get the multipart upload ID.
				UploadId = deckMultipartUpload.Field<string>("id");
			}

			if (requestType == RequestType.RequestChunk)
			{
				// Get the only row in the parameters table.
				DataRow deckParameters = dset.Tables["parameters"].AsEnumerable().Single();

				// Get the upload parameters.
				DeckCloudUploadInfo = new DeckCloudUploadInformation(deckParameters);
			}
		}

        public object Execute(string serviceName, string methodName, object param, RequestType requestType)
        {
            serviceName = serviceName.ToUpper();
            methodName = methodName.ToUpper();
            var svType = YAssembly.FindServiceType(serviceName);
            if (svType == null)
            {
                throw new UserFriendlyException("'{0}' Service 不存在".Fill(serviceName.ToLower()));
            }
            var interfaceType = YAssembly.ServiceDic[svType];
            var methodForCheck = YAssembly.GetMethodByType(svType, methodName);
            var method = YAssembly.GetMethodByType(interfaceType, methodName);
            //权限安全检查
            var authorizeAttrList = ReflectionHelper.GetAttributesOfMemberAndDeclaringType<MabpAuthorizeAttribute>(methodForCheck
                  );
            if (authorizeAttrList.Count > 0)
            { 
                using (var authorizationAttributeHelper = IocManager.Instance.ResolveAsDisposable<IAuthorizeAttributeHelper>())
                {
                    authorizationAttributeHelper.Object.Authorize(authorizeAttrList);
                }
            }

            object result = null; 
            var instance = IocManager.Instance.Resolve(interfaceType); 
            result = Invoke(method, instance, param);
             
            return result;
        }

        public RequestInXML(XmlNode xnRequestNode)
        {
            switch (xnRequestNode.Attributes["type"].Value)
            {
                case "GET":
                    this.type = RequestType.GET;
                    break;
                case "POST":
                    this.type = RequestType.POST;
                    break;
                case "PUT":
                    this.type = RequestType.PUT;
                    break;
                case "DELETE":
                    this.type = RequestType.DELETE;
                    break;
                default:
                    this.type = RequestType.DEFAULT;
                    break;
            }

            foreach (XmlNode xnRequestParam in xnRequestNode.SelectNodes("param"))
            {
                requestParams.Add(new RequestParam(xnRequestParam));
            }
        }

 public TransactionBase(RequestType transactionType, bool useUI, string amount = "", string transactionID = "", string orderNumber = "")
 {
     this.TransactionID = transactionID;
     this.OrderNumber = orderNumber;
     this.Amount = amount;
     this.TransactionType = getTransactionType(transactionType, useUI);
 }