public async Task<string> Login(string username, string password)
        {
            HttpWebRequest request = new HttpWebRequest(new Uri(String.Format("{0}Token", Constants.BaseAddress)));
            request.Method = "POST";

            string postString = String.Format("username={0}&password={1}&grant_type=password", HttpUtility.HtmlEncode(username), HttpUtility.HtmlEncode(password));
            byte[] bytes = Encoding.UTF8.GetBytes(postString);
            using (Stream requestStream = await request.GetRequestStreamAsync())
            {
                requestStream.Write(bytes, 0, bytes.Length);
            }

            try
            {
                HttpWebResponse httpResponse =  (HttpWebResponse)(await request.GetResponseAsync());
                string json;
                using (Stream responseStream = httpResponse.GetResponseStream())
                {
                    json = new StreamReader(responseStream).ReadToEnd();
                }
                TokenResponseModel tokenResponse = JsonConvert.DeserializeObject<TokenResponseModel>(json);
                return tokenResponse.AccessToken;
            }
            catch (Exception ex)
            {
                throw new SecurityException("Bad credentials", ex);
            }
        }
        public async Task<bool> Register(string username, string password, string confirmPassword)
        {
            RegisterModel model = new RegisterModel
            {
                ConfirmPassword = confirmPassword,
                Password = password,
                UserName = username
            };

            HttpWebRequest request = new HttpWebRequest(new Uri(String.Format("{0}api/Account/Register", Constants.BaseAddress)));
            request.Method = "POST";
            request.ContentType = "application/json";
            request.Accept = "application/json";
            string json = JsonConvert.SerializeObject(model);
            byte[] bytes = Encoding.UTF8.GetBytes(json);
            using(Stream stream = await request.GetRequestStreamAsync())
            {
                stream.Write(bytes, 0, bytes.Length);
            }

            try
            {
                await request.GetResponseAsync();
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
Example #3
0
        public async Task <string> SendDiscordOAuthRequestViaAuthCode(string code)
        {
            string authstring = $"https://discordapp.com/api/oauth2/token";

            Web webReq = (Web)WebRequest.Create(authstring);

            webReq.Method = "POST";
            string parameters = $"client_id={_id}&client_secret={_secret}&grant_type=authorization_code&code={code}&redirect_uri={_redirectURL}";

            byte[] byteArray = Encoding.UTF8.GetBytes(parameters);
            webReq.ContentType   = "application/x-www-form-urlencoded";
            webReq.ContentLength = byteArray.Length;
            Stream postStream = await webReq.GetRequestStreamAsync();

            await postStream.WriteAsync(byteArray, 0, byteArray.Length);

            postStream.Close();
            WebResponse response = await webReq.GetResponseAsync();

            postStream = response.GetResponseStream();
            StreamReader reader     = new StreamReader(postStream);
            string       responseFS = await reader.ReadToEndAsync();

            string tokenInfo    = responseFS.Split(',')[0].Split(':')[1];
            string access_token = tokenInfo.Trim().Substring(1, tokenInfo.Length - 3);

            return(access_token);
        }
Example #4
0
        public Task<Stream> GetUploadStreamAsync()
        {
            request = (HttpWebRequest)WebRequest.Create(ms);

            request.Method = ContentMethod.Post;
            request.ContentType = ContentType.Xml;
            request.CookieContainer = cookieContainer;

            return request.GetRequestStreamAsync();
        }
Example #5
0
        public Task<Stream> GetUploadStreamAsync()
        {
            request = (HttpWebRequest)WebRequest.Create("https://secure.nicovideo.jp/secure/login");

            request.Method = ContentMethod.Post;
            request.ContentType = ContentType.Form;
            request.CookieContainer = cookieContainer;

            return request.GetRequestStreamAsync();
        }
Example #6
0
        public Task<Stream> GetUploadStreamAsync()
        {
            request = (HttpWebRequest)WebRequest.Create(
                "http://www.nicovideo.jp/tag_edit/" + id);

            request.Method = ContentMethod.Post;

            request.CookieContainer = cookieContainer;
            request.ContentType = ContentType.Form;
            return request.GetRequestStreamAsync();
        }
Example #7
0
        public async Task <bool> ExecuteAsync()
        {
            try
            {
                this.Watch = System.Diagnostics.Stopwatch.StartNew();
                System.Net.HttpWebRequest webrequest = (HttpWebRequest)System.Net.WebRequest.Create(this.Url);
                webrequest.Method      = this.Method;
                webrequest.ContentType = this.ContentType;
                webrequest.Timeout     = this.TimeoutMilliseconds;
                if (this.Certificate != null)
                {
                    webrequest.ServerCertificateValidationCallback = (message, cert, chain, errors) => true;
                    webrequest.ClientCertificates.Add(this.Certificate);
                }

                switch (this.Method)
                {
                case "PUT":
                case "POST":
                    var byteArray = Encoding.UTF8.GetBytes(this.PayLoad);
                    webrequest.ContentLength = byteArray.Length;
                    await(await webrequest.GetRequestStreamAsync()).WriteAsync(byteArray, 0, byteArray.Length);
                    break;

                case "GET":
                default:
                    webrequest.ContentLength = 0;
                    break;
                }

                this.Request = $"{Url} {PayLoad}";

                using (var response = await webrequest.GetResponseAsync())
                {
                    var responseStream = response.GetResponseStream();
                    this.Watch.Stop();
                    this.ElapsedTime = (int)Watch.ElapsedMilliseconds;
                    this.Response    = await(new StreamReader(response.GetResponseStream())).ReadToEndAsync();
                }
                return(true);
            }
            catch (Exception e)
            {
                this.Watch.Stop();
                this.ElapsedTime = (int)Watch.ElapsedMilliseconds;
                if (e.GetType() == typeof(WebException) && ((WebException)e).Response != null)
                {
                    this.Response = await(new StreamReader(((WebException)e).Response.GetResponseStream())).ReadToEndAsync();
                }

                throw;
            }
        }
Example #8
0
        //测试方法
        public static async Task <string> PostTest(string url, string jsonParas)
        {
            string          str      = string.Empty;
            HttpWebResponse response = null;

            try
            {
                byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(jsonParas);                  //将数据转换成对应的网站编码
                System.Net.HttpWebRequest webRequest = (HttpWebRequest)HttpWebRequest.Create(url); //发出请求
                                                                                                   //ServicePointManager.DefaultConnectionLimit = 100;
                webRequest.ContentType = "application/Json";                                       //报表头类型
                webRequest.Method      = "POST";                                                   //请求方式Post
                                                                                                   // webRequest.Timeout = 12000;//请求的超时时间
                                                                                                   // webRequest.ContentLength = byteArray.Length;//获取要传输的长度
                Stream requeststream = await webRequest.GetRequestStreamAsync();                   //获取写入的数据流

                //StreamWriter strw = new StreamWriter(requeststream);
                requeststream.Write(byteArray, 0, byteArray.Length);//将数据写入到当前流中

                try
                {
                    response = (HttpWebResponse)(await webRequest.GetResponseAsync());//获得响应流
                }
                catch (WebException ex) { response = (HttpWebResponse)ex.Response; }
                if (response == null)
                {
                    throw new Exception("");
                }

                using (var stream2 = response.GetResponseStream())
                {
                    StreamReader reader = new StreamReader(stream2, Encoding.UTF8);
                    string       text   = reader.ReadToEnd();
                    if (text.StartsWith("{"))
                    {
                        return(text);
                    }
                    throw new Exception("返回Json数据失败\r\n" + text);
                }
            }
            finally
            {
                if (response != null)
                {
                    response.Dispose();
                }
            }
        }
Example #9
0
        private static async Task <HttpWebResponse> UploadObject(string bucket, string path, HttpPostedFileBase sourceFile, string preasignedURL)
        {
            System.Net.HttpWebRequest httpRequest = WebRequest.Create(preasignedURL) as HttpWebRequest;
            httpRequest.Method = "PUT";
            using (Stream dataStream = await httpRequest.GetRequestStreamAsync())
            {
                var buffer = new byte[8000];

                int bytesRead = 0;
                while ((bytesRead = await sourceFile.InputStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
                {
                    await dataStream.WriteAsync(buffer, 0, bytesRead);
                }
            }
            HttpWebResponse response = httpRequest.GetResponse() as HttpWebResponse;

            return(response);
        }
		public async Task RegisterExternal(
			string username)
		{
			string uri = String.Format("{0}/api/Account/RegisterExternal", BaseUri);

			RegisterExternalBindingModel model = new RegisterExternalBindingModel
			{
				UserName = username
			};
			HttpWebRequest request = new HttpWebRequest(new Uri(uri));

			request.ContentType = "application/json";
			request.Accept = "application/json";
			request.Headers.Add("Authorization", String.Format("Bearer {0}", AccessToken));
			request.Method = "POST";

			string postJson = JsonConvert.SerializeObject(model);
			byte[] bytes = Encoding.UTF8.GetBytes(postJson);
			using (Stream requestStream = await request.GetRequestStreamAsync())
			{
				requestStream.Write(bytes, 0, bytes.Length);
			}

			try
			{
				WebResponse response = await request.GetResponseAsync();
				HttpWebResponse httpResponse = (HttpWebResponse)response;
				string result;

				using (Stream responseStream = httpResponse.GetResponseStream())
				{
					result = new StreamReader(responseStream).ReadToEnd();
					Console.WriteLine(result);
				}
			}
			catch (SecurityException)
			{
				throw;
			}
			catch (Exception ex)
			{
				throw new InvalidOperationException("Unable to register user", ex);
			}
		}
Example #11
0
        public async Task <Client> RequestPostAsync(string data_string)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(data_string);

            foreach
            (
                KeyValuePair <Uri, ClientRequestImplementation <ImplementationRequest> > kvp
                in this.RequestImplementationObjects
            )
            {
                Uri uri = kvp.Key;
                ImplementationRequest request = kvp.Value.ImplementationObject;

                RequestSetup(request);

                #if NETSTANDARD1_0
                using (Stream stream = await request.GetRequestStreamAsync())
                {
                    await stream.WriteAsync(bytes, 0, bytes.Length);

                    await stream.FlushAsync();
                }

                ImplementationResponse response = (ImplementationResponse)await request.GetResponseAsync();

                this.ResponseImplementationObjects.Add(uri, response);
                #else
                request.Content =
                    new System.Net.Http.StringContent(data_string)
                    //new System.Net.Http.ByteArrayContent(new byte[]{})
                ;

                using (System.Net.Http.HttpClient http_client = new System.Net.Http.HttpClient())
                {
                    ImplementationResponse response = await http_client.SendAsync(request);

                    this.ResponseImplementationObjects.Add(uri, response);
                }
                #endif
            }

            return(this);
        }
Example #12
0
        /// <summary>
        /// 上传的文件
        /// </summary>
        /// <param name="url">服务器请求地址</param>
        /// <param name="paramDate">发送的数据</param>
        /// <param name="encode">网站编码</param>
        /// <returns>字符串类型的true/false</returns>
        public static async Task <string> PostMoth(string url, string paramDate, System.Text.Encoding encode)
        {
            string str = string.Empty;

            try
            {
                byte[] byteArray = encode.GetBytes(paramDate);                                     //将数据转换成对应的网站编码
                System.Net.HttpWebRequest webRequest = (HttpWebRequest)HttpWebRequest.Create(url); //发出请求
                                                                                                   //ServicePointManager.DefaultConnectionLimit = 100;
                webRequest.ContentType = "application/x-www-form-urlencoded";                      //报表头类型
                webRequest.Method      = "POST";                                                   //请求方式Post
                                                                                                   // webRequest.Timeout = 12000;//请求的超时时间
                                                                                                   // webRequest.ContentLength = byteArray.Length;//获取要传输的长度
                Stream requeststream = await webRequest.GetRequestStreamAsync();                   //获取写入的数据流

                //StreamWriter strw = new StreamWriter(requeststream);
                requeststream.Write(byteArray, 0, byteArray.Length);                                  //将数据写入到当前流中
                HttpWebResponse webResponse = (HttpWebResponse)(await webRequest.GetResponseAsync()); //返回来自服务器的相应
                if (webResponse.StatusCode == HttpStatusCode.OK)
                {
                    if (webResponse.Headers["Content-Encoding"] != null && webResponse.Headers["Content-Encoding"].ToLower().Contains("gzip"))//如果http头中接受gzip的话,这里就要判断是否为有压缩,有的话,直接解压缩即可
                    {
                        requeststream = new System.IO.Compression.GZipStream(requeststream,
                                                                             System.IO.Compression.CompressionMode.Decompress); //解压缩基础流
                    }
                    StreamReader strReader = new StreamReader(webResponse.GetResponseStream());                                 //读取对应编码的文件流
                    str = strReader.ReadToEnd();                                                                                //读文件流至最后
                    webResponse.Dispose();
                    strReader.Dispose();
                    requeststream.Dispose();//关闭文件流
                    return("true");
                }
                else
                {
                    return("false");
                }
            }
            catch (Exception e)
            {
                return(e.ToString());
            }
        }
Example #13
0
        public static async Task <bool> UpdateApprovalStatus(string containerId, ApprovalsDetails request)
        {
            bool   result     = false;
            var    jsonstring = JsonConvert.SerializeObject(request);
            string url        = String.Format(API + "{0}/approvalStatus", containerId);

            System.Net.HttpWebRequest requestForJason = (HttpWebRequest)WebRequest.Create(url);
            requestForJason.Method = "POST"; //make an HTTP POST
                                             //  var jsonstring = WebUtility.UrlEncode(JsonConvert.SerializeObject(vehiclebookingdata));// "{\"CarId\":\"\",\"DriverId\":null,\"EmployeeId\":null,\"EmployeeContactNumber\":null,\"EmployeeAddress\":\"Kothrud\",\"EmployeeName\":\"Kunal Kalbande\",\"Status\":\"cancelled\",\"BookingTime\":\"0001-01-01 00:00:00.000 +00:00\",\"Latitude\":18.4994,\"Longitude\":73.8279,\"DriverIds\":[\"adas\",\"asd\"],\"CarType\":\"mini\"}";
            requestForJason.ContentType = "application/json";
            // requestForJason.Accept = "application/json";
            Encoding encoding = new UTF8Encoding();

            byte[] data = encoding.GetBytes(jsonstring);
            using (var stream = await requestForJason.GetRequestStreamAsync())
            {
                // var streamwriter = new StreamWriter(stream);
                //streamwriter.Write(postdata);
                // streamwriter.Flush();
                stream.Write(data, 0, data.Length);
                stream.Dispose();
            }
            string resultResponce = "";

            HttpWebResponse responseLocationMapping = await requestForJason.GetResponseAsync() as HttpWebResponse;

            if (responseLocationMapping != null)
            {
                result = true;
                //string Charset = response.;
                string Charset = "utf-8";
                encoding = Encoding.GetEncoding(Charset);
                var streamReaderResult = new StreamReader(responseLocationMapping.GetResponseStream(), encoding);
                resultResponce = streamReaderResult.ReadToEnd();
                streamReaderResult.Dispose();
            }
            return(result);
        }
Example #14
0
        public async Task<String> GetHttpPostResponse(HttpWebRequest request, string postData)
        {
            Received = null;
            request.Method = "POST";

            request.ContentType = "application/x-www-form-urlencoded";

            var requestBody = Encoding.UTF8.GetBytes(postData);

            // ASYNC: using awaitable wrapper to get request stream
            using (var postStream = await request.GetRequestStreamAsync())
            {
                // Write to the request stream.
                // ASYNC: writing to the POST stream can be slow
                await postStream.WriteAsync(requestBody, 0, requestBody.Length);
            }

            try
            {
                // ASYNC: using awaitable wrapper to get response
                var response = (HttpWebResponse) await request.GetResponseAsync();
                if (response != null)
                {
                    var reader = new StreamReader(response.GetResponseStream());
                    // ASYNC: using StreamReader's async method to read to end, in case
                    // the stream i slarge.
                    Received = await reader.ReadToEndAsync();
                }
            }
            catch (WebException we)
            {
                var reader = new StreamReader(we.Response.GetResponseStream());
                var responseString = reader.ReadToEnd();
                Debug.WriteLine(responseString);
                return responseString;
            }
            return Received;
        }
Example #15
0
        public async Task<string> DownloadStringAsync(HttpWebRequest request, byte[] postData)
        {
            request.UserAgent = SKore.ChromeAgent;
            request.AllowAutoRedirect = false;
            request.CookieContainer = Cookies;
            request.Method = "GET";
            request.Proxy = Proxy;

            if (postData != null)
            {
                request.Method = "POST";
                request.ContentLength = postData.Length;

                using (var reqStream = await request
                    .GetRequestStreamAsync().ConfigureAwait(false))
                {
                    await reqStream.WriteAsync(postData,
                        0, postData.Length).ConfigureAwait(false);
                }
            }

            return (await VerifyResponseBody(
                request).ConfigureAwait(false));
        }
Example #16
0
        private async Task ConfigureRequest(HttpWebRequest request, IEnumerable<FileInfo> files)
        {
            Debug.Assert(request != null);
            Debug.Assert(files != null);

            using (Stream memStream = new MemoryStream())
            {
                string boundary = "-----------------------" + DateTime.Now.Ticks.ToString("x");

                request.Accept = "*/*";
                request.ContentType = "multipart/form-data; boundary=" + boundary;
                request.KeepAlive = true;

                var boundaryBytesMiddle = Encoding.ASCII.GetBytes("\r\n--" + boundary + "\r\n");
                var boundaryBytesLast = Encoding.ASCII.GetBytes("\r\n--" + boundary + "--\r\n");

                await memStream.WriteAsync(boundaryBytesMiddle, 0, boundaryBytesMiddle.Length);

                var headerTemplate = "Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"\r\nContent-Type: {2}\r\n\r\n";

                var count = files.Count();

                Debug.WriteLine("--->Adding {0} files to request.", files.Count());
                foreach (var file in files)
                {
                    Debug.WriteLine("--->Adding file ({0}) to request.", file.FullName);
                    var headerContentType = (file.Extension == ".cer") ? "application/x-x509-ca-cert" : "application/x-zip-compressed";
                    var header = string.Format(headerTemplate, file.Name, file.Name, headerContentType);
                    var headerBytes = Encoding.UTF8.GetBytes(header);
                    await memStream.WriteAsync(headerBytes, 0, headerBytes.Length);

                    using (var fileStream = file.OpenRead())
                    {
                        await fileStream.CopyToAsync(memStream);

                        if (--count > 0)
                        {
                            Debug.WriteLine("--->Padding memstream.");
                            await memStream.WriteAsync(boundaryBytesMiddle, 0, boundaryBytesMiddle.Length);
                            Debug.WriteLine("--->Padded memstream.");
                        }
                        else
                        {
                            Debug.WriteLine("--->Padding memstream (last time).");
                            await memStream.WriteAsync(boundaryBytesLast, 0, boundaryBytesLast.Length);
                            Debug.WriteLine("--->Padded memstream (last time).");
                        }
                    }
                }
                Debug.WriteLine("--->Added files to request.");

                request.ContentLength = memStream.Length;

                Debug.WriteLine("--->Getting request stream.", files.Count());
                using (Stream requestStream = await request.GetRequestStreamAsync())
                {
                    Debug.WriteLine("--->Copying memstream to requestStream");
                    memStream.Position = 0;
                    await memStream.CopyToAsync(requestStream);
                    Debug.WriteLine("--->Copyied memstream to requestStream");
                }
            }
        }
		private static Task<Stream> getRequestStreamAsync(HttpWebRequest request)
		{
			return request.GetRequestStreamAsync();
		}
 public Task<Stream> GetRequestStreamAsync(HttpWebRequest request)
 {
     return request.GetRequestStreamAsync();
 }
    private async Task<ChunkStatus> SendNextChunkAsync(Stream blobStream, int chunkSize, long chunkStart, long bytesTotal) {
      // Errors will be caught by the caller.
      var buffer = new byte[chunkSize];
      int bytesTransferred = await blobStream.ReadAsync(buffer, 0, chunkSize);

      this.request = WebRequestCreator.BrowserHttp.Create(uri) as HttpWebRequest;
      request.Method = "POST";
      request.ContentType = "application/octet-stream"; // default
      request.ContentLength = bytesTransferred;
      // Set headers
      foreach (var entry in this.headers) {
        request.Headers[entry.Key] = entry.Value;
      }
      if (headerAccept != null) request.Accept = headerAccept;
      if (headerContentType != null) request.ContentType = headerContentType;
      // Set content-range, specially
      if (headerContentRange != null) {
        request.Headers["X-MSHACK-Content-Range"] = "" + chunkStart + "-" + (chunkStart + bytesTransferred - 1) + "/" + bytesTotal;
      }

      using (Stream sendStream = await request.GetRequestStreamAsync()) {
        await sendStream.WriteAsync(buffer, 0, bytesTransferred);
      }

      HttpStatusCode status;
      WebHeaderCollection headers;
      string body;

      using (HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse)
      using (Stream responseStream = response.GetResponseStream())
      using (StreamReader reader = new StreamReader(responseStream)) {
        status = response.StatusCode;
        headers = response.GetRealOrFakeHeaders();
        body = await reader.ReadToEndAsync();
      }

      CompletedEventArgs args = new CompletedEventArgs(status, headers, body);
      return new ChunkStatus(bytesTransferred, args);
    }
        private async Task<bool> DoRegionAsyncCall(HttpWebRequest req, KnownNeighborRegion neighbor, MessageType type, byte[] body)
        {
            try
            {
                using (System.IO.Stream reqStream = await req.GetRequestStreamAsync())
                {
                    await reqStream.WriteAsync(body, 0, body.Length);
                }
            }
            catch (Exception e)
            {
                _log.ErrorFormat("[REGIONMANAGER]: Could not post request for {0} to region {1} at {2}: {3}", 
                    type, neighbor.RegionInfo.RegionHandle, Util.RegionHandleToLocationString(neighbor.RegionInfo.RegionHandle), e.Message);
                KillNeighborOnUpMessageFailure(neighbor, type);
                
                return false;
            }

            try
            {
                using (WebResponse response = await req.GetResponseAsync(NEIGHBOR_HANDLER_TIMEOUT))
                {
                    //we dont do anything with the response
                }
            }
            catch (Exception e)
            {
                _log.ErrorFormat("[REGIONMANAGER]: Unable to read response to {0} for region {1} at {2}: {3}", 
                    type, neighbor.RegionInfo.RegionHandle, Util.RegionHandleToLocationString(neighbor.RegionInfo.RegionHandle), e.Message);
                KillNeighborOnUpMessageFailure(neighbor, type);

                return false;
            }

            return true;
        }
        public async virtual void Write(OAuthMessage message, HttpWebRequest request)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            request.Method = this.GetHttpMethod(message);
            request.ContentType = this.GetHttpContentType(message);
            this.Write(message, await request.GetRequestStreamAsync());
        }
Example #22
0
        //查看成绩页面
        private async void btnGrade_Click(object sender, RoutedEventArgs e)
        {
            ProgressView.ProgressIndicator progress = new ProgressView.ProgressIndicator();
            progress.Text = "请等待";
            progress.Show();

            if (gd == null)
            {
                await new MessageDialog("登录有误,请重新登录!").ShowAsync();
                //ShowWaitingRing(false);
                progress.Hide();
                return;
            }
            HttpRequestMessage  request;
            HttpResponseMessage response;

            //    byte[] bytedata;
            try
            {
                HttpBaseProtocolFilter filter = gd.loginInfo.ob as HttpBaseProtocolFilter;
                if (filter == null)
                {
                    //ShowWaitingRing(false);
                    //IsWorking = false;
                    progress.Hide();
                    return;
                }

                HttpClient client = new HttpClient(filter);
                request = new HttpRequestMessage(HttpMethod.Get,
                                                 new Uri("http://gdjwgl.bjut.edu.cn/xscjcx.aspx?xh=" + gd.StudentID + "&xm=" + gd.StudentName + "&gnmkdm=N121605"));

                request.Headers["Referer"] = "http://gdjwgl.bjut.edu.cn/xs_main.aspx?xh=" + gd.StudentID;

                response = await client.SendRequestAsync(request, HttpCompletionOption.ResponseHeadersRead);


                string str = await response.Content.ReadAsStringAsync();

                //request.Dispose();
                //response.Dispose();

                string __VIEWSTATEString;
                __VIEWSTATEString = gd.GetVIEWSTATE(str);

                IDictionary <string, string> parameters = new Dictionary <string, string>();
                parameters.Add("__EVENTTARGET", "");
                parameters.Add("__EVENTARGUMENT", "");
                parameters.Add("__VIEWSTATE", SystemNet.WebUtility.UrlEncode(__VIEWSTATEString));
                parameters.Add("hidLanguage", "");
                parameters.Add("ddlXN", "");
                parameters.Add("ddlXQ", "");
                parameters.Add("ddl_kcxz", "");
                parameters.Add("btn_zcj", SystemNet.WebUtility.UrlEncode("历年成绩"));
                string buffer = "";

                int i = 0;
                foreach (string key in parameters.Keys)
                {
                    if (i > 0)
                    {
                        buffer += "&" + key + "=" + parameters[key];
                    }
                    else
                    {
                        buffer = key + "=" + parameters[key];
                    }
                    i++;
                }


                byte[] bytedata = Encoding.UTF8.GetBytes(buffer);

                SystemNet.HttpWebRequest netrequest = (SystemNet.HttpWebRequest)SystemNet.WebRequest.Create(new Uri("http://gdjwgl.bjut.edu.cn/xscjcx.aspx?xh=" + gd.StudentID + "&xm=" + "" + "&gnmkdm=N121605"));
                netrequest.Headers["Referer"] = "http://gdjwgl.bjut.edu.cn/xscjcx.aspx?xh=" + gd.StudentID + "&xm=" + "" + "&gnmkdm=N121605";
                netrequest.Method             = "POST";

                netrequest.ContentType = "application/x-www-form-urlencoded";


                HttpCookie cookie = filter.CookieManager.GetCookies(new Uri("http://gdjwgl.bjut.edu.cn/xscjcx.aspx?xh=" + gd.StudentID + "&xm=" + gd.StudentName + "&gnmkdm=N121605"))[0];


                netrequest.Headers["Cookie"] = cookie.Name + "=" + cookie.Value;

                using (Stream streamRequest = await netrequest.GetRequestStreamAsync())//从在异步调用问题,
                {
                    streamRequest.Write(bytedata, 0, bytedata.Length);
                }

                SystemNet.HttpWebResponse netrespones = (SystemNet.HttpWebResponse)(await netrequest.GetResponseAsync());

                Stream stream = netrespones.GetResponseStream();
                using (StreamReader sr = new StreamReader(stream, DBCSCodePage.DBCSEncoding.GetDBCSEncoding("gb2312")))
                {
                    string s = sr.ReadToEnd();
                    gd.gc.GetGradeChart(s);
                }

                Frame.Navigate(typeof(Grade), gd);
                //IsWorking = false;
            }
            catch (Exception ex)
            {
                await new MessageDialog(ex.Message).ShowAsync();
                //IsWorking = false;
            }
            finally
            {
                //ShowWaitingRing(false);
                progress.Hide();
            }
        }
        public async Task PostStringAsync(string url, string bodyParameter)
        {
            string info = string.Empty;
            req = HttpWebRequest.CreateHttp(url);
            req.Method = "POST";
            WebResponse res = null;
            try
            {
                using (Stream stream = await req.GetRequestStreamAsync())
                {
                    byte[] buffer = Encoding.UTF8.GetBytes(bodyParameter);
                    await stream.WriteAsync(buffer, 0, buffer.Length);
                    await stream.FlushAsync();
                }
            }
            catch (Exception e)
            {
                OnGetDataEvent(new ProgressEventArgs
                {
                    DownLoadData = null,
                    ExceptionInfo = e.Message,
                    IsComplete = false,
                    IsException = true
                });
                return;
            }

            try
            {
                res = await req.GetResponseAsync();
            }
            catch (Exception e)
            {
                OnGetDataEvent(new ProgressEventArgs
                {
                    DownLoadData = null,
                    ExceptionInfo = e.Message,
                    IsComplete = false,
                    IsException = true
                });
                return;
            }
            //如果返回数据
            if (req.HaveResponse && null != res)
            {
                using (Stream stream = res.GetResponseStream())
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        info = await reader.ReadToEndAsync();
                    }
                }
                OnGetDataEvent(new ProgressEventArgs
                {
                    DownLoadData = info,
                    ExceptionInfo = null,
                    IsComplete = true,
                    IsException = false
                });
            }
            else
            {
                //没有数据
                OnGetDataEvent(new ProgressEventArgs
                {
                    DownLoadData = null,
                    ExceptionInfo = null,
                    IsComplete = false,
                    IsException = true
                });
                return;
            }
        }
Example #24
0
        private Task<Response> CallHttpWithBodyAsync(HttpWebRequest request, byte[] body)
        {
            try
            {
                return Task.Run<Response>(async () =>
                {
                    var requestStream = await request.GetRequestStreamAsync();
                    requestStream.Write(body, 0, body.Length);
                    var response = (HttpWebResponse)await request.GetResponseAsync();
                    var streamResponse = response.GetResponseStream();

                    return new Response() { ResponseStream = streamResponse, StatusCode = response.StatusCode };
                });

            }
            catch
            {
                throw;
            }
        }
Example #25
0
        /// <summary>
        /// Uploads the data into the web request.
        /// </summary>
        /// <param name="request">The request that is setup for a put.</param>
        /// <param name="source">The source of data.</param>
        /// <param name="result">The response from the server.</param>
        /// <returns>The sequence used for uploading data.</returns>
        internal TaskSequence UploadData(HttpWebRequest request, Stream source, Action<WebResponse> result)
        {
            // Retrieve the stream
            var requestStreamTask = request.GetRequestStreamAsync();
            yield return requestStreamTask;

            // Copy the data
            using (var outputStream = requestStreamTask.Result)
            {
                var copyTask = new InvokeTaskSequenceTask(() => { return source.WriteTo(outputStream); });
                yield return copyTask;

                // Materialize any exceptions
                var scratch = copyTask.Result;
            }

            // Get the response
            var responseTask = request.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
            yield return responseTask;

            // Return the response object
            var response = responseTask.Result;

            result(response);
        }
Example #26
0
        /// <summary>
        /// http or https post request
        /// </summary>
        /// <param name="requestInput"></param>
        /// <param name="remoteCertificateValidationCallback"></param>
        /// <returns></returns>
        public static async Task <string> RequestPostAsync(HttpRequestArgs requestInput, Func <object, X509Certificate, X509Chain, SslPolicyErrors, bool> remoteCertificateValidationCallback = null)
        {
            var res = string.Empty;

            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(requestInput.Url);
            try
            {
                request.Method      = "POST";
                request.ContentType = string.IsNullOrEmpty(requestInput.ContentType) ? "application/x-www-form-urlencoded" : requestInput.ContentType; //application/json; encoding=utf-8
                byte[] byte1 = requestInput.GetBodyBytes().Result;
                request.ContentLength = byte1.Length;

                if (requestInput.TimeOut > 0)
                {
                    request.Timeout = requestInput.TimeOut;
                }

                if (!requestInput.Host.IsNullOrWhiteSpace())
                {
                    request.Host = requestInput.Host;
                }

                if (requestInput.Expect100Continue.HasValue)
                {
                    System.Net.ServicePointManager.Expect100Continue = requestInput.Expect100Continue.Value;
                }

                if (requestInput.KeepAlive.HasValue)
                {
                    request.KeepAlive = requestInput.KeepAlive.Value;
                }

                request.ProtocolVersion = requestInput.HttpVer;

                if (!requestInput.UserAgent.IsNullOrWhiteSpace())
                {
                    request.UserAgent = requestInput.UserAgent;
                }

                if (requestInput.DefaultConnectionLimit.HasValue)
                {
                    ServicePointManager.DefaultConnectionLimit = requestInput.DefaultConnectionLimit.Value;
                }

                if (requestInput.DnsRefreshTimeout.HasValue)
                {
                    ServicePointManager.DnsRefreshTimeout = requestInput.DnsRefreshTimeout.Value;
                }

                foreach (var header in requestInput.Headers)
                {
                    request.Headers.Add(header.Key, header.Value);
                }


                //验证服务器证书回调自动验证
                ServicePointManager.ServerCertificateValidationCallback = ((remoteCertificateValidationCallback == null) ? new System.Net.Security.RemoteCertificateValidationCallback(CheckValidationResult) : new System.Net.Security.RemoteCertificateValidationCallback(remoteCertificateValidationCallback));

                using (Stream newStream = await request.GetRequestStreamAsync())
                {
                    // Send the data.
                    newStream.Write(byte1, 0, byte1.Length);    //写入参数
                }

                using (System.Net.HttpWebResponse response = (System.Net.HttpWebResponse)(await request.GetResponseAsync()))
                {
                    Encoding coding = string.IsNullOrEmpty(requestInput.CharSet) ? System.Text.Encoding.UTF8 : System.Text.Encoding.GetEncoding(requestInput.CharSet);
                    using (System.IO.StreamReader reader = new System.IO.StreamReader(response.GetResponseStream(), coding))
                    {
                        var responseMessage = reader.ReadToEnd();
                        if (response.StatusCode == HttpStatusCode.OK)
                        {
                            res = responseMessage;
                        }

                        response.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                res = string.Format("ERROR:{0}", ex.Message);
            }
            finally
            {
                request.Abort();
                request = null;
            }

            return(res);
        }
Example #27
0
 public Task <Stream> GetRequestStreamAsync()
 {
     return(request.GetRequestStreamAsync());
 }
        /// <summary>
        /// Asynchronously performs an HttpWebRequest with request data.
        /// </summary>
        /// <param name="request">Required. The HttpWebRequest to represent the base request.</param>
        /// <param name="contentType">Required. The Content-Type HTTP header to send with the request.</param>
        /// <param name="formData">Required. A FormBuilder object representing the form data to send.</param>
        /// <param name="cancellationToken">Optional. The token to monitor for cancellation requests.</param>
        /// <param name="progressHandler">Optional. The event handler to invoke when progress has changed.</param>
        /// <param name="completeHandler">Optional. The event handler to invoke when the request has finished.</param>
        /// <returns>Returns a HttpWebResponse representing the response from the server.</returns>
        public async Task<HttpWebResponse> RequestAsync(HttpWebRequest request, FormBuilder formData,
            CancellationToken cancellationToken = default(CancellationToken), TaskProgressEventHandler progressHandler = null, TaskCompleteEventHandler completeHandler = null)
        {
            request.ContentLength = formData.Length;

            if (!String.IsNullOrEmpty(formData.ContentType))
                request.ContentType = formData.ContentType;

            // Write to request stream
            using (Stream requestStream = await request.GetRequestStreamAsync())
            {
                await formData.WriteToAsync(requestStream, GetOptimalBufferSize(formData.Length));
            }

            HttpWebResponse result;

            {
                // HttpWebResponse: Start task
                Task<WebResponse> resultTask = request.GetResponseAsync();

                // CompleteHandler: Begin asynchronous invoke
                IAsyncResult completeHandlerResult = null;
                if (completeHandler != null)
                    completeHandler.BeginInvoke(null, null);

                // HttpWebResponse: Await result
                result = (HttpWebResponse)(await resultTask);

                // CompleteHandler: End asynchronous invoke
                if (completeHandler != null && completeHandlerResult != null)
                    completeHandler.EndInvoke(completeHandlerResult);
            }

            return result;
        }
        /// <summary>
        /// Asynchronously performs an HttpWebRequest with request data.
        /// </summary>
        /// <param name="request">Required. The HttpWebRequest to represent the base request.</param>
        /// <param name="contentType">Required. The Content-Type HTTP header to send with the request.</param>
        /// <param name="data">Required. A byte array representing the request data to send with the request.</param>
        /// <param name="cancellationToken">Optional. The token to monitor for cancellation requests.</param>
        /// <param name="progressHandler">Optional. The event handler to invoke when progress has changed.</param>
        /// <param name="completeHandler">Optional. The event handler to invoke when the request has finished.</param>
        /// <returns>Returns a HttpWebResponse representing the response from the server.</returns>
        public async Task<HttpWebResponse> RequestAsync(HttpWebRequest request, string contentType, byte[] data,
            CancellationToken cancellationToken = default(CancellationToken), TaskProgressEventHandler progressHandler = null, TaskCompleteEventHandler completeHandler = null)
        {
            request.ContentLength = (data != null) ? data.Length : 0;

            if (!String.IsNullOrEmpty(contentType))
                request.ContentType = contentType;

            // Write to request stream
            using (Stream requestStream = await request.GetRequestStreamAsync())
            {
                int bufferSize = GetOptimalBufferSize(data.Length);
                int bytesDone = new int();

                while (bytesDone < data.Length)
                {
                    // ProgressHandler: Begin asynchronous invoke
                    IAsyncResult progressHandlerResult = null;
                    if (progressHandler != null)
                        progressHandlerResult = progressHandler.BeginInvoke(Math.Min(1.0, (double)bytesDone / (double)data.Length), null, null);

                    // WriteTask: Start writing to stream asynchronously
                    int nextChunkSize = Math.Min(data.Length - bytesDone, bufferSize);
                    Task writeTask = requestStream.WriteAsync(data, bytesDone, nextChunkSize, cancellationToken);                    

                    // End asynchronous ProgressHandler
                    if (progressHandler != null && progressHandlerResult != null)
                        progressHandler.EndInvoke(progressHandlerResult);

                    // WriteTask: Wait for chunk upload to finish
                    await writeTask;
                    bytesDone += nextChunkSize;
                }
            }

            HttpWebResponse result;

            {
                // HttpWebResponse: Start task
                Task<WebResponse> resultTask = request.GetResponseAsync();

                // CompleteHandler: Begin asynchronous invoke
                IAsyncResult completeHandlerResult = null;
                if (completeHandler != null)
                    completeHandler.BeginInvoke(null, null);

                // HttpWebResponse: Await result
                result = (HttpWebResponse)(await resultTask);

                // CompleteHandler: End asynchronous invoke
                if (completeHandler != null && completeHandlerResult != null)
                    completeHandler.EndInvoke(completeHandlerResult);
            }

            return result;
        }
Example #30
0
        public static async Task<HttpWebResponse> ForwardRequest(HttpRequest req, HttpWebRequest hwr)
        {
            hwr.Method = req.HttpMethod;
            hwr.Timeout = 15000;

            foreach(var hdr in req.Headers.AllKeys) {
                switch(hdr) {
                    case "Accept":
                        hwr.Accept = req.Headers[hdr];
                        break;
                    case "Content-Type":
                        hwr.ContentType = req.ContentType;
                        break;
                    case "Content-Length":
                    case "User-Agent": // Forging UA
                    case "Connection": // Keep alive anyway
                    case "Host":
                    case "Proxy-Connection":
                    case "Range":
                    case "Date":
                    case "Cookie":
                    case "Transfer-Encoding":
                    case "Accept-Encoding":
                    case "Referer":
                        break; //Ignore these.
                    case "Expect":
                        return null;
                    case "If-Modified-Since":
                        {
                            var hdrLine = req.Headers[hdr];
                            var semicolon = hdrLine.IndexOf(';');
                            if(semicolon < 0) semicolon = hdrLine.Length;
                            hdrLine = hdrLine.Substring(0, semicolon);
                            hwr.IfModifiedSince = DateTime.Parse(hdrLine);
                        }
                        break;
                    default:
                        if(WebHeaderCollection.IsRestricted(hdr, false)) {
                            return null;
                        }
                        hwr.Headers[hdr] = req.Headers[hdr];
                        break;
                }
            }

            hwr.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
            hwr.UserAgent = ConfigurationManager.AppSettings["ua"];
            hwr.AllowAutoRedirect = true;
            hwr.KeepAlive = true;

            if(req.HttpMethod != "GET" && req.HttpMethod != "HEAD" && req.ContentLength != 0) {
                req.InputStream.Position = 0;
                using(var outGoingStream = await hwr.GetRequestStreamAsync())
                    await req.InputStream.CopyToAsync(outGoingStream);
            }
            
            try {
                return (HttpWebResponse)await hwr.GetResponseAsync();
            } catch(WebException e) {
                return (HttpWebResponse)e.Response;
            }
        }