public HTTPRequest Request(HTTPMethods method, string path, OnAppRespondedDelegate callback, OnAppRespondedDelegate err) { return(new HTTPRequest( new System.Uri(URI, path), method, (HTTPRequest request_, HTTPResponse response_) => { if (request_.State != HTTPRequestStates.Finished) { request_ = null; Debug.Log("Request " + path + " returned null"); return; } var json = JSON.Parse(request_.Response.DataAsText); if (json != null && json["error"] == json["null"]) { try { callback(json); } catch { Debug.Log("Network request callback threw: " + method.ToString() + ":" + path); } } else { err(json); } })); }
private static void SendOfflineRequest(string endpoint, HTTPMethods method, ApiContainer responseContainer = null, Dictionary <string, object> requestParams = null) { foreach (object offlineQuery in offlineQueries) { Dictionary <string, object> dictionary = offlineQuery as Dictionary <string, object>; if (dictionary["url"].ToString() == endpoint) { object result = dictionary["result"]; string s = Json.Encode(result); byte[] data = Encoding.UTF8.GetBytes(s); responseContainer.OnComplete(success: true, endpoint, 200, string.Empty, () => data, () => Json.Encode(result)); if (!responseContainer.IsValid) { if (responseContainer.OnError != null) { responseContainer.OnError(responseContainer); } } else if (responseContainer.OnSuccess != null) { responseContainer.OnSuccess(responseContainer); } } } Logger.LogErrorFormat(DebugLevel.API, "Query used by application in offline mode not found - {0}", endpoint); responseContainer.Error = "query not found in offline results - " + endpoint; if (responseContainer.OnError != null) { responseContainer.OnError(responseContainer); } }
public HTTPRequest(Uri uri, HTTPMethods methodType, bool isKeepAlive, bool disableCache, OnRequestFinishedDelegate callback) { this.Uri = uri; this.MethodType = methodType; this.IsKeepAlive = isKeepAlive; this.DisableCache = disableCache; this.Callback = callback; this.StreamFragmentSize = 4096; this.DisableRetry = (methodType == HTTPMethods.Post); this.MaxRedirects = 2147483647; this.RedirectCount = 0; this.IsCookiesEnabled = HTTPManager.IsCookiesEnabled; int num = 0; this.DownloadLength = num; this.Downloaded = num; this.DownloadProgressChanged = false; this.State = HTTPRequestStates.Initial; this.ConnectTimeout = HTTPManager.ConnectTimeout; this.Timeout = HTTPManager.RequestTimeout; this.EnableTimoutForStreaming = false; this.Proxy = HTTPManager.Proxy; this.UseUploadStreamLength = true; this.DisposeUploadStream = true; this.CustomCertificateVerifyer = HTTPManager.DefaultCertificateVerifyer; }
internal static HTTPCacheFileInfo Store(Uri uri, HTTPMethods method, HTTPResponse response) { if (response == null || response.Data == null || response.Data.Length == 0) { return(null); } HTTPCacheFileInfo hTTPCacheFileInfo = null; Dictionary <Uri, HTTPCacheFileInfo> obj = HTTPCacheService.Library; lock (obj) { if (!HTTPCacheService.Library.TryGetValue(uri, out hTTPCacheFileInfo)) { HTTPCacheService.Library.Add(uri, hTTPCacheFileInfo = new HTTPCacheFileInfo(uri)); } try { hTTPCacheFileInfo.Store(response); } catch { HTTPCacheService.DeleteEntity(uri, true); throw; } } return(hTTPCacheFileInfo); }
private HTTPRequest NewRequest(string url, HTTPMethods method, HttpManager.Callback callback) { return(new HTTPRequest(new Uri(url), method, true, true, (_request, _response) => { switch (_request.State) { case HTTPRequestStates.Finished: if (_response.IsSuccess) { OnSuccess(_response, callback); } else { OnResponseError(_request, _response, callback); } break; case HTTPRequestStates.Error: OnRequestError(_request, _response, callback); break; case HTTPRequestStates.Aborted: OnRequestError(_request, _response, callback); break; case HTTPRequestStates.ConnectionTimedOut: OnRequestError(_request, _response, callback); break; case HTTPRequestStates.TimedOut: OnRequestError(_request, _response, callback); break; } })); }
internal static HTTPCacheFileInfo Store(Uri uri, HTTPMethods method, HTTPResponse response) { if (response == null || response.Data == null || response.Data.Length == 0) { return(null); } if (!IsSupported) { return(null); } HTTPCacheFileInfo value = null; lock (Library) { if (!Library.TryGetValue(uri, out value)) { Library.Add(uri, value = new HTTPCacheFileInfo(uri)); UsedIndexes.Add(value.MappedNameIDX, value); } try { value.Store(response); return(value); } catch { DeleteEntity(uri); throw; IL_0087: return(value); } } }
internal static HTTPCacheFileInfo Store(Uri uri, HTTPMethods method, HTTPResponse response) { if (response == null || response.Data == null || response.Data.Length == 0) { return(null); } HTTPCacheFileInfo info = null; lock (Library) { if (!Library.TryGetValue(uri, out info)) { Library.Add(uri, info = new HTTPCacheFileInfo(uri)); } try { info.Store(response); } catch { // If something happens while we write out the response, than we will delete it becouse it might be in an invalid state. DeleteEntity(uri); throw; } } return(info); }
/// <summary> /// Checks if the given response can be cached. http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.4 /// </summary> /// <returns>Returns true if cacheable, false otherwise.</returns> internal static bool IsCacheble(Uri uri, HTTPMethods method, HTTPResponse response) { if (method != HTTPMethods.Get) { return(false); } if (response == null) { return(false); } // Already cached if (response.StatusCode == 304) { return(false); } if (response.StatusCode < 200 || response.StatusCode >= 400) { return(false); } //http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.2 var cacheControls = response.GetHeaderValues("cache-control"); if (cacheControls != null) { if (cacheControls.Exists(headerValue => { string value = headerValue.ToLower(); return(value.Contains("no-store") || value.Contains("no-cache")); })) { return(false); } } var pragmas = response.GetHeaderValues("pragma"); if (pragmas != null) { if (pragmas.Exists(headerValue => { string value = headerValue.ToLower(); return(value.Contains("no-store") || value.Contains("no-cache")); })) { return(false); } } // Responses with byte ranges not supported yet. var byteRanges = response.GetHeaderValues("content-range"); if (byteRanges != null) { return(false); } return(true); }
public async Task <IActionResult> AddOrderForm(CreateUpdateFactoryProgramRecordDto entity) { #region 字段合法性验证 //所属车间 必填 if (entity.SpinningMillId == Guid.Empty) { return(Fail("车间信息必传!")); } //所属车间 有效 HttpResponseMessage SpinningMillResult = await HTTPMethods.Get(_httpApiUrlStrs.Value.BusinessApiUrl + AjaxUrls["GetSpinningMillData"].ToString() + entity.SpinningMillId); if (SpinningMillResult.StatusCode != System.Net.HttpStatusCode.OK) { return(Fail("车间信息不存在!")); } //订单号 必填 if (!string.IsNullOrEmpty(entity.Code)) { return(Fail("订单号必填!")); } #endregion HttpResponseMessage result = await HTTPMethods.Post(_httpApiUrlStrs.Value.BusinessApiUrl + AjaxUrls["AddOrderForm"].ToString(), entity.ToJson()); if (result.StatusCode == System.Net.HttpStatusCode.OK) { return(SuccessInfo("新增成功!")); } else { return(Fail("未知错误!")); } }
/// <summary> /// Build a request for backend /// </summary> /// <param name="type">Type.</param> /// <param name="endpoint">Endpoint.</param> void RequestBuilder(HTTPMethods type, string endpoint) { HTTPRequest request = new HTTPRequest(new Uri(BASE_URI + endpoint), type, OnRequestFinished); request.Send(); }
public void HttpRequestByMothdType(HTTPMethods methodType, string param, bool isKeepAlive, bool disableCache, Action <int, string, string> callBack) { string url = BaseUrl + SubPath + param; HTTPManager.SendRequest(url, methodType, isKeepAlive, disableCache, (HTTPRequest originalRequest, HTTPResponse response) => { if (response == null) { callBack(-1, "", ""); return; } string responseStr = ""; int result = 0; string msg = ""; if (response.IsSuccess) { responseStr = Encoding.UTF8.GetString(response.Data); } else { result = response.StatusCode; msg = response.Message; } if (callBack != null) { callBack(result, msg, responseStr); } }); }
public IEnumerator RequestSync(string url, HTTPMethods methods = HTTPMethods.Get, Dictionary <string, string> headers = null, WWWForm param = null, Action <DownloadHandler> onSuccess = null, Action <float> onProgress = null, Action <DownloadHandler> onError = null) { HTTPRequest request = HTTPRequest.GenerateInstance(); return(request.RequestSync( url: url, methods: methods, headers: headers, param: param, onSuccess: (downloadHandler) => { if (onSuccess != null) { onSuccess(downloadHandler); } GameObject.Destroy(request.gameObject); }, onProgress: onProgress, onError: (downloadHandler) => { if (onError != null) { onError(downloadHandler); } GameObject.Destroy(request.gameObject); })); }
public HTTPRequest(Uri uri, HTTPMethods methodType, bool isKeepAlive, bool disableCache, OnRequestFinishedDelegate callback) { Uri = uri; MethodType = methodType; IsKeepAlive = isKeepAlive; DisableCache = disableCache; Callback = callback; StreamFragmentSize = 4096; DisableRetry = (methodType == HTTPMethods.Post); MaxRedirects = 2147483647; RedirectCount = 0; IsCookiesEnabled = HTTPManager.IsCookiesEnabled; int num3 = Downloaded = (DownloadLength = 0); DownloadProgressChanged = false; State = HTTPRequestStates.Initial; ConnectTimeout = HTTPManager.ConnectTimeout; Timeout = HTTPManager.RequestTimeout; EnableTimoutForStreaming = false; Proxy = HTTPManager.Proxy; UseUploadStreamLength = true; DisposeUploadStream = true; CustomCertificateVerifyer = HTTPManager.DefaultCertificateVerifyer; CustomClientCredentialsProvider = HTTPManager.DefaultClientCredentialsProvider; UseAlternateSSL = HTTPManager.UseAlternateSSLDefaultValue; }
/// <summary> /// Tries to find the appropriate HTTPMethod for the given HTTPMethods. /// </summary> /// <param name="myCode">A HTTPMethod code as string</param> /// <returns>A HTTPMethod</returns> public static HTTPMethod ParseEnum(HTTPMethods myHTTPMethodsEnum) { return((from _FieldInfo in typeof(HTTPMethod).GetFields() let __HTTPMethod = _FieldInfo.GetValue(null) as HTTPMethod where __HTTPMethod != null where __HTTPMethod.MethodName == myHTTPMethodsEnum.ToString() select __HTTPMethod).FirstOrDefault()); }
/// <summary> /// Generates a new HTTP mapping. /// </summary> /// <param name="HTTPMethod">The HTTP method of this HTTP mapping.</param> /// <param name="UriTemplate">The URI template of this HTTP mapping.</param> public HTTPMappingAttribute(HTTPMethods HTTPMethod, String UriTemplate) { this.HTTPMethod = de.ahzf.Vanaheimr.Hermod.HTTP.HTTPMethod.ParseEnum(HTTPMethod); if (this.HTTPMethod == null) throw new ArgumentNullException("Invalid HTTPMethod!"); this.UriTemplate = UriTemplate; }
private string Send(HTTPMethods method, string relativeUri, StringBuilder headers, string body, string contentType, string accept) { byte[] bodyBytes = null; if (!string.IsNullOrEmpty(body)) { bodyBytes = new UTF8Encoding().GetBytes(body); } return((string)this.SendBytesArray(relativeUri, headers, bodyBytes, true)); }
private object SendBytesArray(string relativeUri, StringBuilder headers, byte[] bodyBytes, bool isSend = false) { HTTPMethods method = HTTPMethods.POST; var client = new HttpClient(); string requestUri = string.Format("{0}{1}", EndPoint.AbsolutePath, relativeUri); if (isSend) { requestUri = string.Format("{0}{1}", Address, relativeUri); } client.BaseAddress = new Uri(requestUri); Task <HttpResponseMessage> response = null; if (string.IsNullOrEmpty(relativeUri)) { throw new ArgumentException("relativeUri is empty"); } try { switch (method) { case HTTPMethods.POST: case HTTPMethods.PUT: HttpContent content = new ByteArrayContent(bodyBytes); response = client.PostAsync(requestUri, content); break; } } catch (WebException webException) { string body = string.Empty; try { using (var reader2 = new StreamReader(webException.Response.GetResponseStream())) { body = reader2.ReadToEnd(); } } catch { body = "Unable to get response"; } throw new InvalidResponseException("Failed: " + body, webException, (response != null) ? response.Result.StatusCode : HttpStatusCode.BadRequest, body); } catch (Exception exception) { throw new InvalidResponseException("Failed: " + exception.Message, exception); } var streamTask = (StreamContent)response.Result.Content; var text = new StreamReader(streamTask.ReadAsStreamAsync().Result); text.ReadToEnd(); return(response.Result); }
public HTTPRequest(string url, HTTPMethods method, Action <HTTPRequest, HTTPResponse> act, int timeout = 60) { this.act = act; this.request = new UnityWebRequest(url, Methods[method]) { downloadHandler = new DownloadHandlerBuffer(), timeout = timeout, }; }
public HTTPErrorAttribute(HTTPMethods HTTPMethod, String UriTemplate, HTTPStatusCode myHTTPStatusCode) { this.HTTPMethod = org.GraphDefined.Vanaheimr.Hermod.HTTP.HTTPMethod.ParseEnum(HTTPMethod); if (this.HTTPMethod == null) throw new ArgumentNullException("Invalid HTTPMethod!"); this.UriTemplate = UriTemplate; this.HTTPStatusCode = myHTTPStatusCode; }
static void Main(string[] args) { CookieContainer myCookies = new CookieContainer(); HTTPMethods.Login(ref myCookies); string username = "******"; HTTPMethods.ListOfSolvedProblems(username, myCookies); Console.ReadLine(); }
/// <summary> /// Tries to find the appropriate HTTPMethod for the given HTTPMethods. /// </summary> /// <param name="HTTPMethodEnum">A HTTP method.</param> /// <param name="HTTPMethod">The parsed HTTP method.</param> /// <returns>true or false</returns> public static Boolean TryParseEnum(HTTPMethods HTTPMethodEnum, out HTTPMethod HTTPMethod) { HTTPMethod = (from _FieldInfo in typeof(HTTPMethod).GetFields() let __HTTPMethod = _FieldInfo.GetValue(null) as HTTPMethod where __HTTPMethod != null where __HTTPMethod.MethodName == HTTPMethodEnum.ToString() select __HTTPMethod).FirstOrDefault(); return((HTTPMethod != null) ? true : false); }
public void Request(string url, HTTPMethods methods = HTTPMethods.Get, Dictionary <string, string> headers = null, WWWForm param = null, Action <DownloadHandler> onSuccess = null, Action <float> onProgress = null, Action <DownloadHandler> onError = null) { StartCoroutine(RequestSync(url: url, methods: methods, param: param, headers: headers, onSuccess: onSuccess, onProgress: onProgress, onError: onError)); }
public static void SendRequest(string endpoint, HTTPMethods method, ApiContainer responseContainer = null, Dictionary <string, object> requestParams = null, bool authenticationRequired = true, bool disableCache = false, float cacheLifetime = 3600f, int retryCount = 2, CredentialsBundle credentials = null) { if (Logger.DebugLevelIsEnabled(DebugLevel.API)) { Logger.LogFormat(DebugLevel.API, "Requesting {0} {1} {2} disableCache: {3} retryCount: {4}", method, endpoint, (requestParams == null) ? "{{}}" : Json.Encode(requestParams).Replace("{", "{{").Replace("}", "}}"), disableCache.ToString(), retryCount.ToString()); } UpdateDelegator.Dispatch(delegate { SendRequestInternal(endpoint, method, responseContainer, requestParams, authenticationRequired, disableCache, cacheLifetime, retryCount, credentials); }); }
/// <summary> /// Generates a new HTTP mapping. /// </summary> /// <param name="HTTPMethod">The HTTP method of this HTTP mapping.</param> /// <param name="UriTemplate">The URI template of this HTTP mapping.</param> public HTTPMappingAttribute(HTTPMethods HTTPMethod, String UriTemplate) { this.HTTPMethod = HTTP.HTTPMethod.ParseEnum(HTTPMethod); if (this.HTTPMethod == null) { throw new ArgumentNullException("Invalid HTTPMethod!"); } this.UriTemplate = UriTemplate; }
public HTTPErrorAttribute(HTTPMethods HTTPMethod, String UriTemplate, HTTPStatusCode myHTTPStatusCode) { this.HTTPMethod = org.GraphDefined.Vanaheimr.Hermod.HTTP.HTTPMethod.ParseEnum(HTTPMethod); if (this.HTTPMethod == null) { throw new ArgumentNullException("Invalid HTTPMethod!"); } this.UriTemplate = UriTemplate; this.HTTPStatusCode = myHTTPStatusCode; }
public HTTPRequest(Uri uri, HTTPMethods methodType, bool isKeepAlive, bool disableCache, Action<HTTPRequest, HTTPResponse> callback) { Uri = uri; MethodType = methodType; IsKeepAlive = isKeepAlive; DisableCache = disableCache; Callback = callback; StreamFragmentSize = 4096; DisableRetry = (methodType == HTTPMethods.Post); MaxRedirects = 2147483647; RedirectCount = 0; }
private HTTPRequest RequestCreate(Uri uri, HTTPMethods method, OnRequestFinishedDelegate callback) { HTTPRequest request = new HTTPRequest( uri: uri, methodType: method, isKeepAlive: true, disableCache: true, callback: callback ); return(request); }
public async Task <IActionResult> GetOrderList() { HttpResponseMessage result = await HTTPMethods.Get(_httpApiUrlStrs.Value.BusinessApiUrl + AjaxUrls["GetOrderList"].ToString()); if (result.StatusCode == System.Net.HttpStatusCode.OK) { return(SuccessInfo(await result.Content.ReadAsStringAsync())); } else { return(Fail("未知错误!")); } }
private HTTPRequest RequestCreate(Uri uri, HTTPMethods method, OnRequestFinishedDelegate callback) { HTTPRequest request = new HTTPRequest( uri: uri, methodType: method, isKeepAlive: true, disableCache: true, callback: callback ); request.AddHeader("Authorization", this.AccessToken); request.AddHeader("UserID", this.UserID); return(request); }
public async Task <IActionResult> GetMachineStatisticsList(string process_Id, string variety_Id, DateTime?searchDate) { try { string requestUrl = _httpApiUrlStrs.Value.BusinessApiUrl + AjaxUrls["GetMachineStatisticsList"].ToString(); var result = await HTTPMethods.Get(requestUrl); return(Success(result)); } catch (Exception e) { return(Fail("未知错误")); } }
/// <summary> /// Creates a new HTTP event mapping. /// </summary> /// <param name="EventIdentification">The internal identification of the HTTP event.</param> /// <param name="UriTemplate">The URI template of this HTTP event mapping.</param> /// <param name="HTTPMethod">The HTTP method to use.</param> /// <param name="MaxNumberOfCachedEvents">Maximum number of cached events (0 means infinite).</param> /// <param name="RetryIntervallSeconds">The retry intervall in seconds.</param> /// <param name="IsSharedEventSource">The event source may be accessed via multiple URI templates.</param> public HTTPEventMappingAttribute(String EventIdentification, String UriTemplate, HTTPMethods HTTPMethod, UInt32 MaxNumberOfCachedEvents = 0, UInt64 RetryIntervallSeconds = 30, Boolean IsSharedEventSource = false) { this.EventIdentification = EventIdentification; this.UriTemplate = UriTemplate; this.HTTPMethod = org.GraphDefined.Vanaheimr.Hermod.HTTP.HTTPMethod.ParseEnum(HTTPMethod); this.MaxNumberOfCachedEvents = MaxNumberOfCachedEvents; this.RetryIntervall = TimeSpan.FromSeconds(RetryIntervallSeconds); this.IsSharedEventSource = IsSharedEventSource; }
internal static bool IsCacheble(Uri uri, HTTPMethods method, HTTPResponse response) { if (!IsSupported) { return(false); } if (method != 0) { return(false); } if (response == null) { return(false); } if (response.StatusCode == 304) { return(false); } if (response.StatusCode < 200 || response.StatusCode >= 400) { return(false); } List <string> headerValues = response.GetHeaderValues("cache-control"); if (headerValues != null && headerValues.Exists(delegate(string headerValue) { string text2 = headerValue.ToLower(); return(text2.Contains("no-store") || text2.Contains("no-cache")); })) { return(false); } List <string> headerValues2 = response.GetHeaderValues("pragma"); if (headerValues2 != null && headerValues2.Exists(delegate(string headerValue) { string text = headerValue.ToLower(); return(text.Contains("no-store") || text.Contains("no-cache")); })) { return(false); } List <string> headerValues3 = response.GetHeaderValues("content-range"); if (headerValues3 != null) { return(false); } return(true); }
protected void CreateRequest(string action, Action<HTTPRequest, HTTPResponse> callback, HTTPMethods methodType = HTTPMethods.Get) { request = new HTTPRequest (new Uri (_host + action), methodType, (HTTPRequest req, HTTPResponse res) => { if (interstitialLoading) { _dispatcher.Dispatch("loading_interstitial_close"); } // if finished correctly if (req.State == HTTPRequestStates.Finished) { ClearError(); callback(req, res); } // if not show an error with a retry and/or a go back to main menu else { Debug.Log (req.State); ShowError(); GameAnalytics.NewErrorEvent (GA_Error.GAErrorSeverity.GAErrorSeverityCritical , "Failed connection: " + PlayerPrefs.GetString("username") + " | " + action + " | " + req.State); } }); // add options AddOptions (); }
public HTTPRequest(Uri uri, HTTPMethods methodType, bool isKeepAlive, bool disableCache, Action<HTTPRequest, HTTPResponse> callback) { this.Uri = uri; this.MethodType = methodType; this.IsKeepAlive = isKeepAlive; this.DisableCache = disableCache; this.Callback = callback; this.StreamFragmentSize = 4 * 1024; this.DisableRetry = methodType == HTTPMethods.Post; this.MaxRedirects = int.MaxValue; this.RedirectCount = 0; this.IsCookiesEnabled = HTTPManager.IsCookiesEnabled; Downloaded = DownloadLength = 0; DownloadProgressChanged = false; State = HTTPRequestStates.Initial; ConnectTimeout = HTTPManager.ConnectTimeout; Timeout = HTTPManager.RequestTimeout; EnableTimoutForStreaming = false; }
internal static HTTPCacheFileInfo Store(Uri uri, HTTPMethods method, HTTPResponse response) { if (response == null || response.Data == null || response.Data.Length == 0) return null; HTTPCacheFileInfo info = null; lock (Library) { if (!Library.TryGetValue(uri, out info)) Library.Add(uri, info = new HTTPCacheFileInfo(uri)); try { info.Store(response); } catch { // If something happens while we write out the response, than we will delete it becouse it might be in an invalid state. DeleteEntity(uri); throw; } } return info; }
/// <summary> /// Checks if the given response can be cached. http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.4 /// </summary> /// <returns>Returns true if cacheable, false otherwise.</returns> internal static bool IsCacheble(Uri uri, HTTPMethods method, HTTPResponse response) { if (method != HTTPMethods.Get) return false; if (response == null) return false; // Already cached if (response.StatusCode == 304) return false; if (response.StatusCode < 200 || response.StatusCode >= 400) return false; //http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.2 var cacheControls = response.GetHeaderValues("cache-control"); if (cacheControls != null && cacheControls[0].ToLower().Contains("no-store")) return false; var pragmas = response.GetHeaderValues("pragma"); if (pragmas != null && pragmas[0].ToLower().Contains("no-cache")) return false; // Responses with byte ranges not supported yet. var byteRanges = response.GetHeaderValues("content-range"); if (byteRanges != null) return false; return true; }
public HTTPRequest(Uri uri, HTTPMethods methodType, bool isKeepAlive, Action<HTTPRequest, HTTPResponse> callback) : this(uri, methodType, isKeepAlive, HTTPManager.IsCachingDisabled, callback) { }
public static HTTPRequest SendRequest(string url, HTTPMethods methodType, bool isKeepAlive, bool disableCache, OnRequestFinishedDelegate callback) { return SendRequest(new HTTPRequest(new Uri(url), methodType, isKeepAlive, disableCache, callback)); }
public static HTTPRequest SendRequest(string url, HTTPMethods methodType, OnRequestFinishedDelegate callback) { return SendRequest(new HTTPRequest(new Uri(url), methodType, callback)); }
public static HTTPRequest SendRequest(string url, HTTPMethods methodType, Action<HTTPRequest, HTTPResponse> callback) { return SendRequest(new HTTPRequest(new Uri(url), methodType, callback)); }
public static HTTPRequest SendRequest(string url, HTTPMethods methodType, bool isKeepAlive, bool disableCache, Action<HTTPRequest, HTTPResponse> callback) { return SendRequest(new HTTPRequest(new Uri(url), methodType, isKeepAlive, disableCache, callback)); }