private void BeginRequest(WebRequest request, Action <HttpStatusCode, string, OAuthTokens> onComplete, Action <Uri, Exception> onError, string data)
{
request.BeginGetRequestStream(HandleRequestCallback,
new RequestContext <string, OAuthTokens>
{
Body = data,
Request = request,
OnComplete = onComplete,
OnError = onError
});
}
private void cmdGetDataXmlHttp_Click(object sender, RoutedEventArgs e)
{
Uri address = new Uri("http://api.flickr.com/services/xmlrpc/");
WebRequest request = WebRequest.Create(address);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
// Prepare the request asynchronously.
request.BeginGetRequestStream(CreateRequest, request);
}
void IRpcClientTransaction.SendRequest <T>(RpcRequestHeader request, T args, Action <RpcResponseHeader> callback, int timeout)
{
_callback = callback;
_serviceUrl = string.Format("{0}/{1}.{2}", request.ServerUri, request.Service, request.Method);
_webRequest = HttpWebRequest.Create(_serviceUrl);
_webRequest.Method = "POST";
_webRequest.Proxy = null;
_webRequest.ContentType = "multipart/byteranges";
_webRequest.Headers.Add(HttpRequestHeader.From, request.ServiceAtComputer);
_webRequest.Headers.Add(HttpRequestHeader.Pragma, _serviceUrl);
_webRequest.Headers.Add(HttpRequestHeader.Cookie, "to=" + ObjectHelper.ToString(request.ToUri));
byte[] buffer = null;
if (!request.HasBody)
{
_webRequest.Headers.Add("Null", "true");
_webRequest.ContentLength = 0;
}
else
{
buffer = ProtoBufSerializer.ToByteArray <T>(args);
_webRequest.ContentLength = buffer.Length;
}
timeout = timeout > 0 ? timeout : _channel.Timeout;
if (timeout > 0)
{
_waitHandle = new ManualResetEvent(false);
ThreadPool.RegisterWaitForSingleObject(_waitHandle, new WaitOrTimerCallback(TimeoutCallback), this, timeout, true);
}
if (_webRequest.ContentLength == 0)
{
_webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
}
else
{
_webRequest.BeginGetRequestStream(
delegate(IAsyncResult asyncResult) {
try {
Stream stream = _webRequest.EndGetRequestStream(asyncResult);
stream.Write(buffer, 0, buffer.Length);
stream.Close();
_webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
} catch (Exception ex) {
var resp = RpcResponseHeader.CreateError(RpcErrorCode.SendFailed, ex);
_callback(resp);
}
},
this
);
}
}
public static Stream GetWebRequestStream(this WebRequest request)
{
var autoResetEvent = new AutoResetEvent(false);
var asyncResult = request.BeginGetRequestStream(r => autoResetEvent.Set(), null);
// Wait until the call is finished
autoResetEvent.WaitOne();
return(request.EndGetRequestStream(asyncResult));
}
// extension method for web request to get the request stream with a proper timeout
public static Stream GetRequestStreamWithTimeout(this WebRequest request)
{
IAsyncResult worker = request.BeginGetRequestStream(null, null);
if (!worker.AsyncWaitHandle.WaitOne(request.Timeout))
{
TimeoutException ex = new TimeoutException();
throw new WebException(ex.Message, ex, WebExceptionStatus.Timeout, null);
}
return(request.EndGetRequestStream(worker));
}
private void Send(XDocument resultDocument)
{
_resultDocument = resultDocument;
string serverURL = OperationsOnSettings.Instance.ServerURL;
WebRequest webRequest = WebRequest.Create(string.Format("{0}PostResults", serverURL));
_webRequest = webRequest;
webRequest.Method = "POST";
webRequest.BeginGetRequestStream(new AsyncCallback(GetRequestStreamCallback), webRequest);
}
public void Execute()
{
if (WriteToRequest == null)
{
DoRequest();
}
else
{
requestAsyncResult = Request.BeginGetRequestStream(x => WriteToRequestCallback(), null);
ThreadPool.RegisterWaitForSingleObject(requestAsyncResult.AsyncWaitHandle, TimeOutCallback, null, Request.Timeout, true);
}
}
public Stream GetRequestStream(WebRequest request)
{
ManualResetEvent evt = new ManualResetEvent(false);
Stream requestStream = null;
request.BeginGetRequestStream((IAsyncResult ar) => {
requestStream = request.EndGetRequestStream(ar);
evt.Set();
}, null);
evt.WaitOne();
return(requestStream);
}
internal Stream GetRequestStream(WebRequest request)
{
Stream stream = null;
request.BeginGetRequestStream(a =>
{
stream = request.EndGetRequestStream(a);
allDone.Set();
}, null);
allDone.WaitOne(TimeSpan.FromSeconds(30));
return(stream);
}
static void Main()
{
//<Snippet1>
// Create a new request to the mentioned URL.
WebRequest myWebRequest = WebRequest.Create("http://www.contoso.com");
// Create an instance of the RequestState and assign
// 'myWebRequest' to it's request field.
RequestState myRequestState = new RequestState();
myRequestState.request = myWebRequest;
myWebRequest.ContentType = "application/x-www-form-urlencoded";
// Set the 'Method' property to 'POST' to post data to a Uri.
myRequestState.request.Method = "POST";
//</Snippet1>
// Start the Asynchronous 'BeginGetRequestStream' method call.
IAsyncResult r = (IAsyncResult)myWebRequest.BeginGetRequestStream(
new AsyncCallback(ReadCallback), myRequestState);
// Pause the current thread until the async operation completes.
Console.WriteLine("main thread waiting...");
allDone.WaitOne();
// Assign the response object of 'WebRequest' to a 'WebResponse' variable.
WebResponse myWebResponse = myWebRequest.GetResponse();
Console.WriteLine("The string has been posted.");
Console.WriteLine("Please wait for the response...");
Stream streamResponse = myWebResponse.GetResponseStream();
StreamReader streamRead = new StreamReader(streamResponse);
Char[] readBuff = new Char[256];
int count = streamRead.Read(readBuff, 0, 256);
Console.WriteLine("\nThe contents of the HTML page are ");
while (count > 0)
{
String outputData = new String(readBuff, 0, count);
Console.Write(outputData);
count = streamRead.Read(readBuff, 0, 256);
}
// Close the Stream Object.
streamResponse.Close();
streamRead.Close();
// Release the HttpWebResponse Resource.
myWebResponse.Close();
}
private static void BeginRequest(WebRequest request, Action <HttpStatusCode, string, OAuthTokens> onComplete, Action <Uri, Exception> onError, string data)
{
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.BeginGetRequestStream(HandleRequestCallback,
new RequestContext <string, OAuthTokens>
{
Body = data,
Request = request,
OnComplete = onComplete,
OnError = onError
});
}
/// <summary>
/// Method creates the web request and sends it immediately.
/// Relies upon the requestState PacketId and MessageList being
/// set appropriately.
/// </summary>
/// <param name="requestState">Request state.</param>
private void InternalSendMessage(RequestState requestState)
{
// bundle up the data into a string
Dictionary <string, object> packet = new Dictionary <string, object>();
packet[OperationParam.ServiceMessagePacketId.Value] = requestState.PacketId;
packet[OperationParam.ServiceMessageSessionId.Value] = m_sessionID;
packet[OperationParam.ServiceMessageMessages.Value] = requestState.MessageList;
string jsonRequestString = JsonWriter.Serialize(packet);
string sig = CalculateMD5Hash(jsonRequestString + m_secretKey);
byte[] byteArray = Encoding.UTF8.GetBytes(jsonRequestString);
requestState.Signature = sig;
requestState.ByteArray = byteArray;
if (m_debugPacketLossRate > 0.0)
{
System.Random r = new System.Random();
requestState.LoseThisPacket = r.NextDouble() > m_debugPacketLossRate;
}
if (!requestState.LoseThisPacket)
{
#if !(DOT_NET)
Dictionary <string, string> formTable = new Dictionary <string, string>();
formTable["Content-Type"] = "application/json; charset=utf-8";
formTable["X-SIG"] = sig;
WWW request = new WWW(m_serverURL, byteArray, formTable);
#else
WebRequest request = WebRequest.Create(m_serverURL);
request.ContentType = "application/json; charset=utf-8";
request.Method = "POST";
request.Headers.Add("X-SIG", sig);
request.ContentLength = byteArray.Length;
// TODO: Convert to using a task as BeginGetRequestStream can block for minutes
requestState.AsyncResult = request.BeginGetRequestStream(new AsyncCallback(GetRequestCallback), requestState);
#endif
requestState.WebRequest = request;
}
requestState.RequestString = jsonRequestString;
requestState.TimeSent = DateTime.Now;
ResetIdleTimer();
m_brainCloudClientRef.Log("OUTGOING "
+ (requestState.Retries > 0 ? " Retry(" + requestState.Retries + "): " : ": ")
+ jsonRequestString);
}
public void CustomIsolatedStorageWebRequest()
{
IWebRequestCreate creator = (IWebRequestCreate) new IsolatedStorageWebRequest();
Assert.IsTrue(WebRequest.RegisterPrefix("iso", creator), "iso-1");
Assert.IsFalse(WebRequest.RegisterPrefix("iso", creator), "iso-2");
WebRequest wr = WebRequest.Create(new Uri("iso://site/data.log"));
wr.Method = "SAVE";
IAsyncResult result = wr.BeginGetRequestStream(null, String.Empty);
result.AsyncWaitHandle.WaitOne();
Stream s = wr.EndGetRequestStream(result);
using (StreamWriter sw = new StreamWriter(s)) {
sw.WriteLine("hello");
}
result = wr.BeginGetResponse(null, String.Empty);
result.AsyncWaitHandle.WaitOne();
Assert.IsNull(wr.EndGetResponse(result), "Response-Write");
wr.Method = "LOAD";
// should be in response but that would require a lot of extra code ;-)
result = wr.BeginGetRequestStream(null, String.Empty);
result.AsyncWaitHandle.WaitOne();
s = wr.EndGetRequestStream(result);
using (StreamReader sr = new StreamReader(s)) {
Assert.IsTrue(sr.ReadToEnd().StartsWith("hello"), "ReadToEnd");
}
result = wr.BeginGetResponse(null, String.Empty);
result.AsyncWaitHandle.WaitOne();
Assert.IsNull(wr.EndGetResponse(result), "Response-Read");
}
public Response Send(Event e)
{
Validate(e);
string json = GenerateRequestJSONString(e);
// Make POST request
WebRequest request = WebRequest.Create(ClusterURL + "/save");
request.ContentType = "text/json";
request.Method = "POST";
// Set JSON data
AutoResetEvent autoResetEventStream = new AutoResetEvent(false);
IAsyncResult asyncResultStream = request.BeginGetRequestStream(r => autoResetEventStream.Set(), null);
// Wait until tit's finished
autoResetEventStream.WaitOne();
Stream stream = request.EndGetRequestStream(asyncResultStream) as Stream;
StreamWriter streamWriter = new StreamWriter(stream);
streamWriter.Write(json);
streamWriter.Flush();
// Send and wait
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
IAsyncResult asyncResult = request.BeginGetResponse(r => autoResetEvent.Set(), null);
// Wait until the call is finished
autoResetEvent.WaitOne();
HttpWebResponse response = request.EndGetResponse(asyncResult) as HttpWebResponse;
int code = (int)response.StatusCode;
if (code != 200)
{
throw new WebException(code.ToString() + ": " + ClusterURL + "/save isn't reachable");
}
// Parse JSON body
string body;
using (var sr = new StreamReader(response.GetResponseStream()))
{
body = sr.ReadToEnd();
}
// Decode JSON string into Response object
Response decoded = JsonConvert.DeserializeObject <Response>(body);
return(decoded);
}
public void Post <T>(WebRequest request, T entity, Action <HttpStatusCode, string> onComplete, Action <Uri, Exception> onError)
{
SetStandardHeaders(request, _credentials.Maybe(_ => _.Username), _credentials.Maybe(_ => _.Password));
request.Method = "POST";
request.ContentType = "application/json";
request.BeginGetRequestStream(HandleRequestCallback <T>,
new RequestContext <T, string>
{
Body = entity.ToJson(),
Request = request,
OnComplete = (code, s, response) => onComplete(code, s),
OnError = onError,
});
}
/// <summary>
///
/// </summary>
/// <param name="uri"></param>
/// <param name="postData"></param>
/// <param name="contentType"></param>
public void SendRequest(Uri uri, byte[] postData, string contentType)
{
_webRequest = WebRequest.Create(uri);
_webRequest.Method = Method;
if (postData != null)
{
_webRequest.ContentType = contentType;
_webRequest.BeginGetRequestStream(BeginRequest, postData);
}
else
{
_webRequest.BeginGetResponse(BeginResponse, null);
}
}
private static Stream GetRequestStreamInternal(WebRequest request)
{
// build the envent
using (var revent = new ManualResetEvent(false))
{
// start the async call
IAsyncResult result = request.BeginGetRequestStream(CallStreamCallback, revent);
// wait for event
revent.WaitOne();
// return data stream
return(request.EndGetRequestStream(result));
}
}
public static Task <Stream> GetRequestStreamAsync(this WebRequest webRequest)
{
TaskCompletionSource <Stream> taskComplete = new TaskCompletionSource <Stream>();
webRequest.BeginGetRequestStream(arg =>
{
try
{
Stream requestStream = webRequest.EndGetRequestStream(arg);
taskComplete.TrySetResult(requestStream);
}
catch (Exception ex) { taskComplete.SetException(ex); }
}, webRequest);
return(taskComplete.Task);
}
private static void SendRequestToConsulo(string url, JSONClass jsonClass)
{
WebRequest request = WebRequest.Create("http://localhost:" + PluginConstants.ourPort + "/api/" + url);
request.Timeout = ourTimeout;
request.Method = "POST";
request.ContentType = "application/json; charset=utf-8";
WebRequestState state = new WebRequestState
{
Request = request,
Json = jsonClass.ToString(),
};
request.BeginGetRequestStream(new AsyncCallback(WriteCallback), state);
}
/// <summary>
/// PUT - asynchronous - using actions as handlers
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="request"></param>
/// <param name="entity"></param>
/// <param name="onComplete"></param>
/// <param name="onError"></param>
public void Put <TRequest, TResponse>(WebRequest request, TRequest entity, Action <HttpStatusCode, string, TResponse> onComplete,
Action <Uri, Exception> onError)
where TResponse : class
{
ApiRequestHelper.SetStandardHeaders(request, _configuration, _credentials, _oauth);
request.Method = "PUT";
request.ContentType = "application/json";
request.BeginGetRequestStream(HandleRequestCallback <TResponse>,
new RequestContext <TResponse>
{
Body = entity.ToJson(),
Request = request,
OnComplete = onComplete,
OnError = onError,
});
}
private void cmdGetData_Click(object sender, RoutedEventArgs e)
{
Uri address = new Uri("http://localhost:" +
HtmlPage.Document.DocumentUri.Port + "/ASPWebSite/PopulationService.ashx");
WebRequest request = WebRequest.Create(address);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
// Store the year you want to use.
searchYear = txtYear.Text;
// Prepare the request asynchronously.
request.BeginGetRequestStream(CreateRequest, request);
}
public async void upload_file(StorageFile file)
{
if (file == null)
{
file =
await
StorageFile.GetFileFromApplicationUriAsync(
new Uri("ms-appx:///Assets/SplashScreen.scale-200.png"));
}
string UP_HOST = "http://up.qiniu.com";
string url = UP_HOST;
WebRequest request = WebRequest.Create(url);
request.Method = "POST";
request.BeginGetRequestStream(async result =>
{
HttpWebRequest http = (HttpWebRequest)result.AsyncState;
byte[] buffer = new byte[1024];
using (Stream stream = http.EndGetRequestStream(result))
{
//using (Windows.Storage.StorageStreamTransaction transaction = await file.OpenTransactedWriteAsync())
//{
// using (resource)
// {
// }
//}
using (IRandomAccessStream read_stream = await file.OpenAsync(FileAccessMode.Read))
{
using (DataReader data_reader = new DataReader(read_stream))
{
ulong size = read_stream.Size;
if (size <= uint.MaxValue)
{
await data_reader.LoadAsync((uint)size);
buffer = new byte[size];
data_reader.ReadBytes(buffer);
}
}
}
stream.Write(buffer, 0, buffer.Length);
http.BeginGetResponse(response_call_back, http);
}
}, request);
}
/// <summary>
/// 发出一个异步 POST 请求。
/// </summary>
/// <param name="url">请求的 url。</param>
/// <param name="param">Post 请求的参数。</param>
/// <param name="success">请求成功时执行的方法。</param>
/// <param name="failure">请求失败时执行的方法。</param>
public static void PostAsync(string url, object param = null, Action <string> success = null, Action <WebException> failure = null)
{
try
{
if (string.IsNullOrWhiteSpace(url) == true)
{
throw new ArgumentException("url 不能为空。");
}
if (url.Contains("://") == false)
{
url = "http://" + url;
}
WebRequest request = HttpWebRequest.Create(new Uri(url));
request.Method = "POST";
request.ContentType = @"application/x-www-form-urlencoded";
byte[] bytes = Encoding.UTF8.GetBytes(ObjectToRequestData(param));
request.ContentLength = bytes.Length;
request.BeginGetRequestStream((IAsyncResult result) =>
{
using (Stream stream = request.EndGetRequestStream(result))
{
stream.Write(bytes, 0, bytes.Length);
}
request.BeginGetResponse((IAsyncResult result2) =>
{
using (WebResponse response = request.EndGetResponse(result2))
{
using (StreamReader sr = new StreamReader(response.GetResponseStream()))
{
if (success != null)
{
success(sr.ReadToEnd());
}
}
}
}, request);
}, request);
}
catch (WebException ex)
{
if (failure != null)
{
failure(ex);
}
}
}
public string Proxy(string szURL, string PostData)
{
if (ConfigurationManager.AppSettings["RAgProxyDomain"] != null)
{
szURL = ConfigurationManager.AppSettings["RAgProxyDomain"] + szURL.Substring(szURL.IndexOf("/BFWglobal"));
}
else
{
szURL = "http://int-bcs.bedfordstmartins.com" + szURL.Substring(szURL.IndexOf("/BFWglobal"));
}
WebRequest request = WebRequest.Create(szURL);
request.Method = "POST";
RequestState state = new RequestState
{
request = request
};
request.ContentType = "application/x-www-form-urlencoded";
state.request.Method = "POST";
state.progress = state.progress + "Method set ----\n";
state.PostData = PostData;
state.progress = state.progress + "PostData set ----\n";
request.BeginGetRequestStream(new AsyncCallback(RAgLocalWebService.ReadCallback), state);
allDone.WaitOne();
WebResponse response = request.GetResponse();
state.progress = state.progress + "Request sent ----\n";
Stream responseStream = response.GetResponseStream();
StreamReader reader = new StreamReader(responseStream);
char[] buffer = new char[0x100];
int length = reader.Read(buffer, 0, 0x100);
string str = "";
while (length > 0)
{
string str2 = new string(buffer, 0, length);
str = str + str2;
length = reader.Read(buffer, 0, 0x100);
}
responseStream.Close();
reader.Close();
response.Close();
return(str);
}
// Thực thi
public string Perform()
{
string result = "";
// Create a new request to the mentioned URL.
WebRequest myWebRequest = WebRequest.Create("http://www.google.com/translate_t?langpair=" + Language);
// Create an instance of the RequestState and assign
// 'myWebRequest' to it's request field.
RequestState myRequestState = new RequestState();
myRequestState.request = myWebRequest;
myWebRequest.ContentType = "application/x-www-form-urlencoded";
// Set the 'Method' property to 'POST' to post data to a Uri.
myRequestState.request.Method = "POST";
// Start the Asynchronous 'BeginGetRequestStream' method call.
IAsyncResult r = (IAsyncResult)myWebRequest.BeginGetRequestStream(
new AsyncCallback(ReadCallback), myRequestState);
// Pause the current thread until the async operation completes.
allDone.WaitOne();
// Assign the response object of 'WebRequest' to a 'WebResponse' variable.
WebResponse myWebResponse = myWebRequest.GetResponse();
Stream streamResponse = myWebResponse.GetResponseStream();
StreamReader streamRead = new StreamReader(streamResponse, Encoding.Default, true);
string tempString = streamRead.ReadToEnd();
string szMau = "<div id=result_box dir=\"ltr\">";
int index1 = tempString.IndexOf(szMau) + szMau.Length;
int index2 = tempString.IndexOf("</div>", index1);
result = tempString.Substring(index1, index2 - index1);
result = result.Replace("'", "'");
result = result.Replace(""", "\"");
result = result.Replace("<", "<");
result = result.Replace(">", ">");
// Close the Stream Object.
streamResponse.Close();
streamRead.Close();
// Release the HttpWebResponse Resource.
myWebResponse.Close();
return(result);
}
/// <summary>
/// get the request stream asynchronously
/// </summary>
/// <param name="request">the request</param>
/// <returns>the request stream to write on</returns>
public static Task <Stream> GetRequestStreamAsync(this WebRequest request)
{
var taskComplete = new TaskCompletionSource <Stream>();
request.BeginGetRequestStream(asyncStream =>
{
try
{
Stream requestStream = (Stream)request.EndGetRequestStream(asyncStream);
taskComplete.TrySetResult(requestStream);
}
catch (Exception e)
{
taskComplete.TrySetException(e);
}
}, request);
return(taskComplete.Task);
}
private static Stream getRequestStream(WebRequest request)
{
Stream requestStream = null;
ManualResetEvent getRequestFinished = new ManualResetEvent(false);
AsyncCallback callBack = new AsyncCallback(ar =>
{
var req = (HttpWebRequest)ar.AsyncState;
requestStream = req.EndGetRequestStream(ar);
getRequestFinished.Set();
});
var async = request.BeginGetRequestStream(callBack, request);
getRequestFinished.WaitOne();
return(requestStream);
}
public static Task <Stream> GetRequestStreamAsync(this WebRequest request)
{
var taskSource = new TaskCompletionSource <Stream>();
request.BeginGetRequestStream(ar =>
{
try
{
var webRequest = ar.AsyncState as WebRequest;
var stream = webRequest.EndGetRequestStream(ar);
taskSource.TrySetResult(stream);
}
catch (Exception ex)
{
taskSource.TrySetException(ex);
}
}, request);
return(taskSource.Task);
}
public static void MakeRequest(string requestUrl, string data,
ReplyDelegate action)
{
ServicePointManagerTimeoutSupport.ResetHosts();
WebRequest request = WebRequest.Create(requestUrl);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int length = (int)buffer.Length;
request.ContentLength = length;
request.BeginGetRequestStream(delegate(IAsyncResult res)
{
Stream requestStream = request.EndGetRequestStream(res);
requestStream.Write(buffer, 0, length);
request.BeginGetResponse(delegate(IAsyncResult ar)
{
string reply = String.Empty;
using (WebResponse response = request.EndGetResponse(ar))
{
try
{
using (Stream s = response.GetResponseStream())
using (StreamReader r = new StreamReader(s))
reply = r.ReadToEnd();
}
catch (System.InvalidOperationException)
{
}
}
action(requestUrl, data, reply);
}, null);
}, null);
}
/// <summary>
/// Send http request from lua
/// </summary>
/// <param name="url"></param>
/// <param name="data"></param>
/// <param name="method"></param>
/// <param name="headers"></param>
/// <param name="callback"></param>
public void lua_send_http_request(String url, String data, String method, String userAgent, String contentType, object headers, String callback)
{
WebRequest request = WebRequest.Create(url);
request.Credentials = CredentialCache.DefaultCredentials;
((HttpWebRequest)request).UserAgent = userAgent;
request.Method = method;
request.ContentLength = data.Length;
request.ContentType = contentType;
Stream stream = request.GetRequestStream();
StreamWriter sw = new StreamWriter(stream);
sw.Write(data);
request.ContentLength = stream.Length;
IAsyncResult iar = request.BeginGetRequestStream(new AsyncCallback(this.lua_web_response), new RequestState()
{
Request = (HttpWebRequest)request, Callback = callback, URL = url
});
}