public HttpClient(string endpoint, HttpVerb httpVerb, NameValueCollection headers, string contentType, string parameters) { try { this.Request = (HttpWebRequest)WebRequest.Create(endpoint); this.Request.ContentLength = 0; this.Request.ContentType = contentType.ToString(); this.Request.Method = httpVerb.ToString(); if (headers != null) { foreach (var key in headers.AllKeys) { this.Request.Headers.Add(key, headers[key]); } } if (this.Request.Method == HttpVerb.POST.ToString() && !String.IsNullOrEmpty(parameters)) { var encoding = new UTF8Encoding(); var bytes = Encoding.GetEncoding("utf-8").GetBytes(parameters); this.Request.ContentLength = bytes.Length; using (var writeStream = Request.GetRequestStream()) { writeStream.Write(bytes, 0, bytes.Length); } } } catch (Exception ex) { throw new ArgumentException(String.Format("Create WebRequest Error: {0}", ex.Message)); } }
/// <summary> /// Make an HTTP request, with the given query args /// </summary> /// <param name="url">The URL of the request</param> /// <param name="httpVerb">The HTTP verb to use</param> /// <param name="argument">String thar represents the request data, must be in JSON format</param> private static string MakeRequest(Uri url, HttpVerb httpVerb, string argument = null) { var request = (HttpWebRequest)WebRequest.Create(url); request.Method = httpVerb.ToString(); request.ContentType = "application/json"; if (httpVerb == HttpVerb.POST) { var encoding = new ASCIIEncoding(); var postDataBytes = new byte[0]; if (argument != null) { postDataBytes = encoding.GetBytes(argument); } request.ContentLength = postDataBytes.Length; var requestStream = request.GetRequestStream(); requestStream.Write(postDataBytes, 0, postDataBytes.Length); requestStream.Close(); } try { using (var response = (HttpWebResponse)request.GetResponse()) { var reader = new StreamReader(response.GetResponseStream()); return reader.ReadToEnd(); } } catch (WebException e) { throw new CoticulaApiException("Server Error", e.Message); } }
public RestWebRequest(Uri uri, HttpVerb verb) { _baseRequest = new RestRequest(HttpWebRequest.Create(uri)); _baseRequest.Method = verb.ToString(); InitRequest(); }
/// <summary> /// Make an HTTP request, with the given query args /// </summary> /// <param name="url">The URL of the request</param> /// <param name="httpVerb">The HTTP verb to use</param> /// <param name="args">Dictionary of key/value pairs that represents /// the key/value pairs for the request</param> /// <param name="contentType"></param> /// <exception cref="FacebookApiException"></exception> /// <exception cref="SecurityException"></exception> internal string Request(string url, HttpVerb httpVerb, Dictionary<string, string> args, out string contentType) { if (args != null && args.Keys.Count > 0 && httpVerb == HttpVerb.Get) { url = url+ (url.Contains("?") ? "&" : "?") + EncodeDictionary(args); } var request = (HttpWebRequest)WebRequest.Create(url); request.Proxy = Proxy; request.Timeout = (int)Timeout.TotalMilliseconds; request.Headers.Add(HttpRequestHeader.AcceptLanguage, Culture.IetfLanguageTag.ToLowerInvariant()); request.Accept = "text/javascript"; request.Method = httpVerb.ToString(); if (httpVerb == HttpVerb.Post) { string postData = EncodeDictionary(args); byte[] postDataBytes = Encoding.UTF8.GetBytes(postData); request.ContentType = "application/x-www-form-urlencoded"; request.ContentLength = postDataBytes.Length; try { using (Stream requestStream = request.GetRequestStream()) { requestStream.Write(postDataBytes, 0, postDataBytes.Length); } } catch(WebException ex) { if (ex.Status == WebExceptionStatus.Timeout) throw OperationTimeout(ex); throw; } catch (Exception ex) { throw TransportError(ex); } } HttpWebResponse response; try { using (response = (HttpWebResponse)request.GetResponse()) { contentType = ExtractContentType(response); return new StreamReader(response.GetResponseStream()).ReadToEnd(); } } catch (WebException ex) { if (ex.Status == WebExceptionStatus.ProtocolError) { response = (HttpWebResponse)ex.Response; contentType = ExtractContentType(response); if (contentType == "text/javascript") { using (response) { return new StreamReader(response.GetResponseStream()).ReadToEnd(); } } } throw TransportError(ex); } catch (Exception ex) { throw TransportError(ex); } }
/// <summary> /// Make an HTTP request, with the given query args /// </summary> /// <param name="url">The URL of the request</param> /// <param name="verb">The HTTP verb to use</param> /// <param name="args">Dictionary of key/value pairs that represents /// the key/value pairs for the request</param> private string MakeRequest(Uri url, HttpVerb httpVerb, Dictionary<string, string> args) { if (args != null && args.Keys.Count > 0 && httpVerb == HttpVerb.GET) { url = new Uri(url.ToString() + EncodeDictionary(args, true)); } HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest; request.Method = httpVerb.ToString(); if (httpVerb == HttpVerb.POST) { string postData = EncodeDictionary(args, false); ASCIIEncoding encoding = new ASCIIEncoding(); byte[] postDataBytes = encoding.GetBytes(postData); request.ContentType = "application/x-www-form-urlencoded"; request.ContentLength = postDataBytes.Length; Stream requestStream = request.GetRequestStream(); requestStream.Write(postDataBytes, 0, postDataBytes.Length); requestStream.Close(); } try { using (HttpWebResponse response = request.GetResponse() as HttpWebResponse) { StreamReader reader = new StreamReader(response.GetResponseStream()); return reader.ReadToEnd(); } } catch (WebException e) { throw new FacebookAPIException("Server Error", e.Message); } }
// The Actual Request Method public static string MakeRequest(string uri, string parameters, HttpVerb method, string postData, CookieContainer cookieContainer, string userAgent, string contentType, WebHeaderCollection customHeaders) { try { // Create request and setup Headers var request = WebRequest.Create(uri + parameters) as HttpWebRequest; request.Method = method.ToString(); request.UserAgent = userAgent; request.CookieContainer = cookieContainer; //request.Accept = "*/*"; // Add Custom Headers if we have some, this includes our Authentication Header if (customHeaders != null && customHeaders.Count > 0) { // NOTE: You cannot add the following Special Headers - http://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.headers.aspx request.Headers.Add(customHeaders); } #region HTTP Authentication Methods // Add a Custom Auth Header if we have one. // if (!string.IsNullOrEmpty(authHeader)) { request.Headers.Add(HttpRequestHeader.Authorization, "Basic " + authHeader); } // Authentication using a Credential Cache // request.Credentials = GetCredential(uri, "username", "password"); // Manual Basic Authentication // string username = "******"; // string password = "******"; // string encoded = System.Convert.ToBase64String(Encoding.UTF8.GetBytes(username + ":" + password)); // request.Headers.Add("Authorization", "Basic " + encoded); #endregion // Post Data if (method == HttpVerb.POST) { // HACK: The Android Version Requires a Content Length Header even if the post data is null request.ContentLength = 0; if (!string.IsNullOrEmpty(postData)) { var bytes = Encoding.UTF8.GetBytes(postData); request.ContentType = contentType; request.ContentLength = bytes.Length; using (var requestStream = request.GetRequestStream()) { requestStream.Write(bytes, 0, bytes.Length); } } } using (var response = (HttpWebResponse)request.GetResponse()) using (var responseStream = response.GetResponseStream()) { // Throw an Exception on Error if (response.StatusCode != HttpStatusCode.OK) { throw new Exception(String.Format("Server error (HTTP {0}: {1}).", response.StatusCode, response.StatusDescription)); } // TODO: Is this check necessary? let it throw an exception if there is no response Stream string responseText = string.Empty; if (responseStream != null) { using (var sr = new StreamReader(responseStream)) { responseText = sr.ReadToEnd(); } } // Done, return the response as Text for further processing. return responseText; } } catch (Exception e) { Console.WriteLine(e.Message); return null; } }
// eo GetStringResponse /// <summary> /// Gets the string response from the passed endpoint. /// </summary> /// <returns>The string response, if any.</returns> /// <param name="url">Endpoint URL.</param> /// <param name="verb">HTTP Verb.</param> /// <param name="authToken">Auth token, if any.</param> /// <param name="requestBody">Request body.</param> /// <param name="format">Request Format.</param> /// <param name="encoding">Request Encoding.</param> /// <param name="additionalHeaders">Additional headers.</param> public async Task<WebServiceStringResult> GetStringResponse ( String url, HttpVerb verb, String authToken, AuthorizationType authType = AuthorizationType.NOT_APPLICABLE, String requestBody = null, RequestDataFormatType format = RequestDataFormatType.JSON, RequestEncodingType encoding = RequestEncodingType.UTF8, List<HttpRequestHeader> additionalHeaders = null ) { // Set up the call details. if (String.IsNullOrWhiteSpace (url)) throw new ArgumentException ("URL cannot be null or whitespace."); else this.EndpointUri = new Uri (url); this.RequestDataFormat = format; this.ResponseDataFormat = ResponseDataFormatType.JSON; this.RequestEncoding = encoding; this.AdditionalHeaders = additionalHeaders; this.RequestBody = requestBody; if (String.IsNullOrWhiteSpace (authToken)) { this.AuthenticationToken = null; this.AuthenticationTokenType = AuthorizationType.NOT_APPLICABLE; } else { this.AuthenticationToken = authToken; this.AuthenticationTokenType = authType; } // Make the call and return the result. switch (verb) { case HttpVerb.GET: return await GetCall (); case HttpVerb.POST: return await PostCall (); case HttpVerb.PUT: return await PutCall (); case HttpVerb.DELETE: return await DeleteCall (); default: throw new NotImplementedException (String.Format ("Support for verb {0} is not yet implemented.", verb.ToString ())); } }
/// <summary> /// Make an HTTP request, with the given query args /// Added by Nicolas Nowinski (ThinkPlusPlus.com) to support Pictures on 7/18/2010. /// </summary> /// <param name="url">The URL of the request</param> /// <param name="verb">The HTTP verb to use</param> /// <param name="args">Dictionary of key/value pairs that represents /// the key/value pairs for the request</param> private byte[] MakeRequestImage(Uri url, HttpVerb httpVerb, Dictionary<string, string> args) { if (args != null && args.Keys.Count > 0 && httpVerb == HttpVerb.GET) { url = new Uri(url.ToString() + EncodeDictionary(args, true)); } HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest; request.Method = httpVerb.ToString(); if (httpVerb == HttpVerb.POST) { string postData = EncodeDictionary(args, false); ASCIIEncoding encoding = new ASCIIEncoding(); byte[] postDataBytes = encoding.GetBytes(postData); request.ContentType = "application/x-www-form-urlencoded"; request.ContentLength = postDataBytes.Length; Stream requestStream = request.GetRequestStream(); requestStream.Write(postDataBytes, 0, postDataBytes.Length); requestStream.Close(); } try { using (HttpWebResponse response = request.GetResponse() as HttpWebResponse) { //Credit goes to Greg Beech: http://social.msdn.microsoft.com/Forums/en-US/netfxnetcom/thread/13f919db-b9e0-4978-9bfe-16f0fcf2a51e Stream reader = response.GetResponseStream(); MemoryStream cloneStream = new MemoryStream(0x1000); byte[] buffer = new byte[0x1000]; int bytesInBuffer; while ((bytesInBuffer = reader.Read(buffer, 0, buffer.Length)) > 0) { cloneStream.Write(buffer, 0, bytesInBuffer); } cloneStream.Flush(); byte[] completeData = cloneStream.GetBuffer(); return completeData; //return reader.BaseStream.(); } } catch (WebException e) { throw new FacebookAPIException("Server Error", e.Message); } }
private static void MakeRequest(string contentType, HttpVerb method, string url, object parameters, Action<WebHeaderCollection, Stream> successCallback, Action<WebException> failCallback) { if (parameters == null) { throw new ArgumentNullException("parameters object cannot be null"); } if (string.IsNullOrWhiteSpace(url)) { throw new ArgumentException("url is empty"); } try { /* * Create new Request */ HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(new Uri(url)); request.CookieContainer = cookies; request.Method = method.ToString(); /* * Asynchronously get the response */ if (method == HttpVerb.Delete || method == HttpVerb.Post || method == HttpVerb.Put || method == HttpVerb.Patch) { request.ContentType = contentType; request.BeginGetRequestStream(new AsyncCallback((IAsyncResult callbackResult) => { HttpWebRequest tmprequest = (HttpWebRequest)callbackResult.AsyncState; Stream postStream; postStream = tmprequest.EndGetRequestStream(callbackResult); string postbody = ""; postbody = Utils.SerializeQueryString(parameters); // Convert the string into a byte array. byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(postbody); // Write to the request stream. postStream.Write(byteArray, 0, byteArray.Length); postStream.Flush(); postStream.Dispose(); // Start the asynchronous operation to get the response tmprequest.BeginGetResponse(ProcessCallback(successCallback,failCallback), tmprequest); }), request); } else if (method == HttpVerb.Get || method == HttpVerb.Head) { request.BeginGetResponse(ProcessCallback(successCallback,failCallback), request); } } catch (WebException webEx) { failCallback(webEx); } }
/// <summary> /// Upload an array of files to a remote host using the HTTP post or put multipart method /// </summary> /// <param name="url">Target url</param> /// <param name="method">Request Method - POST or PUT</param> /// <param name="parameters">Parmaters</param> /// <param name="files">An array of files</param> /// <param name="successCallback">Funciton that is called on success</param> /// <param name="failCallback">Function that is called on failure</param> public static void Upload(string url, HttpVerb method, object parameters, NamedFileStream[] files, Action<WebHeaderCollection, Stream> successCallback,Action<WebException> failCallback) { if (method != HttpVerb.Post && method != HttpVerb.Put) { throw new ArgumentException("Request method must be POST or PUT"); } try { /* * Generate a random boundry string */ string boundary = RandomString(12); HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(new Uri(url)); request.Method = method.ToString(); request.ContentType = "multipart/form-data, boundary=" + boundary; request.CookieContainer = cookies; request.BeginGetRequestStream(new AsyncCallback((IAsyncResult asynchronousResult) => { /* * Create a new request */ HttpWebRequest tmprequest = (HttpWebRequest)asynchronousResult.AsyncState; /* * Get a stream that we can write to */ Stream postStream = tmprequest.EndGetRequestStream(asynchronousResult); string querystring = "\n"; /* * Serialize parameters in multipart manner */ #if NETFX_CORE foreach (var property in parameters.GetType().GetTypeInfo().DeclaredProperties) #else foreach (var property in parameters.GetType().GetProperties()) #endif { querystring += "--" + boundary + "\n"; querystring += "content-disposition: form-data; name=\"" + System.Uri.EscapeDataString(property.Name) + "\"\n\n"; querystring += System.Uri.EscapeDataString(property.GetValue(parameters, null).ToString()); querystring += "\n"; } /* * Then write query string to the postStream */ byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(querystring); postStream.Write(byteArray, 0, byteArray.Length); /* * A boundary string that we'll reuse to separate files */ byte[] closing = System.Text.Encoding.UTF8.GetBytes("\n--" + boundary + "--\n"); /* * Write each files to the postStream */ foreach (NamedFileStream file in files) { /* * A temporary buffer to hold the file stream * Not sure if this is needed ??? */ Stream outBuffer = new MemoryStream(); /* * Additional info that is prepended to the file */ string qsAppend; qsAppend = "--" + boundary + "\ncontent-disposition: form-data; name=\""+file.Name +"\"; filename=\"" + file.Filename + "\"\r\nContent-Type: " + file.ContentType + "\r\n\r\n"; /* * Read the file into the output buffer */ StreamReader sr = new StreamReader(file.Stream); outBuffer.Write(System.Text.Encoding.UTF8.GetBytes(qsAppend), 0, qsAppend.Length); int bytesRead = 0; byte[] buffer = new byte[4096]; while ((bytesRead = file.Stream.Read(buffer, 0, buffer.Length)) != 0) { outBuffer.Write(buffer, 0, bytesRead); } /* * Write the delimiter to the output buffer */ outBuffer.Write(closing, 0, closing.Length); /* * Write the output buffer to the post stream using an intemediate byteArray */ outBuffer.Position = 0; byte[] tempBuffer = new byte[outBuffer.Length]; outBuffer.Read(tempBuffer, 0, tempBuffer.Length); postStream.Write(tempBuffer, 0, tempBuffer.Length); postStream.Flush(); } postStream.Flush(); postStream.Dispose(); tmprequest.BeginGetResponse(ProcessCallback(successCallback, failCallback), tmprequest); }), request); } catch (WebException webEx) { failCallback(webEx); } }
/// <summary> /// Make an HTTP request, with the given query args /// </summary> private string MakeRequest(Uri url, HttpVerb httpVerb, List<KeyValuePair<string, string>> args, JSONObject body, ContentType contentType = ContentType.JSON) { // Prepare HTTP url url = PrepareUrl(url, AccessToken, args); // Set request HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest; request.Method = httpVerb.ToString(); if ((httpVerb == HttpVerb.POST) || (httpVerb == HttpVerb.PUT)) { // Prepare HTTP body string postData = EncodeBody(body, contentType); ASCIIEncoding encoding = new ASCIIEncoding(); byte[] postDataBytes = encoding.GetBytes(postData); // Set content type & length if (contentType == ContentType.JSON) { request.ContentType = "application/json"; } else { request.ContentType = "application/x-www-form-urlencoded"; } request.ContentLength = postDataBytes.Length; // Call API Stream requestStream = request.GetRequestStream(); requestStream.Write(postDataBytes, 0, postDataBytes.Length); requestStream.Close(); } try { using (HttpWebResponse response = request.GetResponse() as HttpWebResponse) { // Read response data StreamReader reader = new StreamReader(response.GetResponseStream()); string responseBody = reader.ReadToEnd(); // Understand REST response if (SuccessfulCall(response.StatusCode)) { // Ok return responseBody; } else { // Problem try { // Try throwing a well-formed api error JSONObject errorBody = JSONObject.CreateFromString(responseBody); throw new RESTAPIException(errorBody.Dictionary["error"].Dictionary["type"].String, errorBody.Dictionary["error"].Dictionary["message"].String); } catch (RESTAPIException restEx) { throw restEx; // this is a well-formed error message } catch { throw new RESTAPIException(response.StatusCode.ToString(), responseBody); // this is not a well-formed message } } } } catch (WebException e) { throw new RESTAPIException("Server Error", e.Message); } }
/// <summary> /// Make REST request. /// </summary> /// <param name="target">Target URL. Contains names of objects to be requested.</param> /// <param name="method">HTTP method. Reflects type of operation required [add/delete/get].</param> /// <param name="parameters">REST request parameters.</param> /// <param name="data">Data to send to server. Only appropriate when making POST request.</param> /// <returns>Response string representation</returns> public string MakeRequest(string target, HttpVerb method = HttpVerb.Get, Dictionary<string, string> parameters = null, string data = null) { if ((parameters != null) && parameters.Any()) { target += "?"; // Append all URL parameters parameters.Aggregate(target, (current, parameter) => current + string.Format("{0}={1}", parameter.Key, parameter.Value)); } var request = (HttpWebRequest)WebRequest.Create(target); // Set request header request.Method = method.ToString().ToUpper(); request.ContentLength = 0; request.ContentType = "text\\xml"; if (target.Contains("https://")) { request.ServerCertificateValidationCallback += (sender, certificate, chain, errors) => { return certificate.Equals(Certificate); }; } // Set authorization header var credentials = Convert.ToBase64String(Encoding.GetBytes(string.Format("{0}:{1}", UserName, Password))); request.Headers.Add(HttpRequestHeader.Authorization, "Basic " + credentials); // Append post data if (!string.IsNullOrEmpty(data) && ((method == HttpVerb.Post) || (method == HttpVerb.Put))) { var bytes = Encoding.GetBytes(data); request.ContentLength = bytes.Length; using (var writeStream = request.GetRequestStream()) { writeStream.Write(bytes, 0, bytes.Length); } } // Make request HttpWebResponse response = null; try { response = (HttpWebResponse)request.GetResponse(); } catch (WebException ex) { response = (HttpWebResponse)ex.Response; } RequestCounter++; if (response != null) { switch (response.StatusCode) { case HttpStatusCode.Created: case HttpStatusCode.OK: // Read the response using (var responseStream = response.GetResponseStream()) { if (responseStream != null) { using (var reader = new StreamReader(responseStream)) { return reader.ReadToEnd(); } } return null; } case HttpStatusCode.BadRequest: // Build error string var error = new StringBuilder(); error.AppendLine("Bad request. The data was: " + data); throw new InvalidOperationException(error.ToString()); case HttpStatusCode.NotFound: throw new InstanceNotFoundException("Object doesn't exist."); default: var message = String.Format("Request failed. Received HTTP {0}", response.StatusCode); throw new ApplicationException(message); } } return null; }
internal IAsyncResult BeginRequest( string url, HttpVerb httpVerb, Dictionary<string, string> args, AsyncCallback cb, object state) { if (args != null && args.Keys.Count > 0 && httpVerb == HttpVerb.Get) url = url+ (url.Contains("?") ? "&" : "?") + EncodeDictionary(args); var request = (HttpWebRequest)WebRequest.Create(url); request.Proxy = Proxy; request.Headers.Add(HttpRequestHeader.AcceptLanguage, Culture.IetfLanguageTag.ToLowerInvariant()); request.Method = httpVerb.ToString(); var tar = new TypedAsyncResult<ResponseData>(cb, state); Action beginGetResp = () => request.BeginGetResponse(tar.AsSafe(gr => { HttpWebResponse resp; Stream respStm; string contentType; try { resp = (HttpWebResponse)request.EndGetResponse(gr); contentType = ExtractContentType(resp); respStm = resp.GetResponseStream(); } catch (WebException ex) { if (ex.Status == WebExceptionStatus.ProtocolError) { resp = (HttpWebResponse)ex.Response; contentType = ExtractContentType(resp); if (contentType == "text/javascript") { respStm = resp.GetResponseStream(); goto ok; } } throw TransportError(ex); } ok: var buf = new byte[4096]; var ms = new MemoryStream(buf.Length); AsyncCallback cbr = null; cbr = tar.AsSafe(br => { int cnt = respStm.EndRead(br); if (cnt == 0) { if (!tar.IsCompleted) { ((IDisposable)resp).Dispose(); ms.Seek(0, SeekOrigin.Begin); tar.Complete(new ResponseData { Json = Encoding.UTF8.GetString(ms.ToArray()), ContentType = contentType, }, false); } } else { ms.Write(buf, 0, cnt); respStm.BeginRead(buf, 0, buf.Length, cbr, null); } }, ex => ((IDisposable)resp).Dispose()); respStm.BeginRead(buf, 0, buf.Length, cbr, null); }), null); try { if (httpVerb == HttpVerb.Post) { string postData = EncodeDictionary(args); byte[] postDataBytes = Encoding.UTF8.GetBytes(postData); request.ContentType = "application/x-www-form-urlencoded"; request.ContentLength = postDataBytes.Length; request.BeginGetRequestStream(tar.AsSafe(rar => { Stream rqStm = request.EndGetRequestStream(rar); rqStm.BeginWrite(postDataBytes, 0, postDataBytes.Length, tar.AsSafe(wr => { rqStm.EndWrite(wr); beginGetResp(); }), null); }), null); } else { beginGetResp(); } } catch (Exception ex) { if (!tar.IsCompleted) tar.Complete(true, ex); } return tar; }