C# RequestType类代码示例

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