C# HttpClient.GetStreamAsync方法代码示例

 static void Main(string[] args)
 {
     string address = "http://127.0.0.1:645";
     Uri uri = new Uri(address);
     Console.WriteLine(uri.AbsolutePath); 
     HttpClient http = new HttpClient();
     HttpClientHandler cd = new HttpClientHandler();
     HttpContent hc = 
     
     http.GetStreamAsync(uri);
     Console.WriteLine(http.GetStreamAsync(uri).Result.ToString());
     Console.ReadLine();
 }

        public async Task UploadJpegPhoto()
        {
            IPlanGridApi client = PlanGridClient.Create();
            Stream payload = typeof(PhotoTests).Assembly.GetManifestResourceStream("PlanGrid.Api.Tests.TestData.Sample.jpg");
            Photo photo = await client.UploadPngPhoto(TestData.Project2Uid, "test name", payload);

            Assert.AreEqual("test name", photo.Title);
            Assert.AreEqual(TestData.ApiTestsUserUid, photo.CreatedBy.Uid);
            Assert.AreNotEqual(photo.CreatedAt, default(DateTime));

            using (var downloader = new HttpClient(new HttpClientHandler { AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip, AllowAutoRedirect = true }))
            {
                Stream returnedPayload = await downloader.GetStreamAsync(photo.Url);
                payload = typeof(PhotoTests).Assembly.GetManifestResourceStream("PlanGrid.Api.Tests.TestData.Sample.jpg");
                var payloadBytes = new MemoryStream();
                await payload.CopyToAsync(payloadBytes);
                var returnedBytes = new MemoryStream();
                await returnedPayload.CopyToAsync(returnedBytes);
                Assert.IsTrue(payloadBytes.ToArray().SequenceEqual(returnedBytes.ToArray()));
            }

            Photo retrievedPhoto = await client.GetPhotoInProject(TestData.Project2Uid, photo.Uid);
            Assert.AreEqual("test name", retrievedPhoto.Title);
            await client.UpdatePhoto(TestData.Project2Uid, photo.Uid, new PhotoUpdate { Title = "new title" });
            retrievedPhoto = await client.GetPhotoInProject(TestData.Project2Uid, photo.Uid);
            Assert.AreEqual("new title", retrievedPhoto.Title);

            Assert.IsFalse(retrievedPhoto.IsDeleted);
            await client.RemovePhoto(TestData.Project2Uid, photo.Uid);
            Photo removedPhoto = await client.GetPhotoInProject(TestData.Project2Uid, photo.Uid);
            Assert.IsTrue(removedPhoto.IsDeleted);
        }

        private static void DownloadInParallel(IEnumerable<Show> showsToDownload)
        {
            var po = new ParallelOptions {MaxDegreeOfParallelism = MaxSimultaneousDownloads};
            Parallel.ForEach(showsToDownload, po, show =>
                {
                    try
                    {
                        using (var httpClient = new HttpClient())
                        {
                            var downloadStream = httpClient.GetStreamAsync(show.Mp3Uri).Result;

                            var file = new FileInfo(_saveDirectory + string.Format(@"\Hanselminutes_{0}.mp3", show.Id));
                            using (downloadStream)
                            using (var fileStream = file.Create())
                            {
                                Console.WriteLine(string.Format("Downloading show {0}", show.Id));
                                downloadStream.CopyTo(fileStream);
                            }

                            Console.WriteLine(string.Format("Show {0} downloaded to {1}", show.Id, file));
                        }
                    }
                    catch (Exception e)
                    {
                        Console.Error.WriteLine(e);
                    }
                });
        }

        public static async Task<Stream> LoadToStream(this Uri source)
        {
#if NETFX_CORE || (WINDOWS_PHONE && !WINDOWS_PHONE7)
            switch (source.Scheme.ToLowerInvariant())
            {
                case "ms-appx":
                case "ms-appdata":
                    var file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(source);
                    return await file.OpenStreamForReadAsync();
                default:
                    using (var client = new HttpClient())
                    {
                        using (var stream = await client.GetStreamAsync(source))
                        {
                            var result = new MemoryStream();
                            await stream.CopyToAsync(result);
                            result.Seek(0, SeekOrigin.Begin);
                            return result;
                        }
                    }
            }
#else
            using (var client = new HttpClient())
            {
                return await client.GetStreamAsync(source);
            }
#endif
        }

 public static async Task<Image> LoginInitAndGetloginVcode(bool IsFirst = false)
 {
     try
     {
         var handler = new HttpClientHandler() { CookieContainer = cookieContainers, AllowAutoRedirect = true, AutomaticDecompression = DecompressionMethods.GZip };
         using (var httpClient = new HttpClient(handler))
         {
             httpClient.DefaultRequestHeaders.Add("Host", "kyfw.12306.cn");
             httpClient.DefaultRequestHeaders.Add("Origin", ConstantKey.loginorigin);
             httpClient.DefaultRequestHeaders.Add("Referer", ConstantKey.loginRefer);
             httpClient.DefaultRequestHeaders.Add("UserAgent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.131");
             ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, errors) => true;
             if (IsFirst)
             {
                 //loginInit
                 string loginInit = await httpClient.GetStringAsync(ConstantKey.loginInit);
                 if (string.IsNullOrEmpty(loginInit) || !loginInit.Contains("登录")) return null;
                 //loginJs
                 var resp = await httpClient.GetAsync(ConstantKey.loginJs);
                 if (!resp.IsSuccessStatusCode) return null;
             }
             //VerifyCode
             var verifyStream = await httpClient.GetStreamAsync(ConstantKey.loginVcode);
             if (verifyStream == null) return null;
             return Image.FromStream(verifyStream);
         }
     }
     catch (Exception ex)
     {
         return null;
     }
 }

        //gets the summoner name from the search form and finds the corresponding ID 
        //then calls to create the 3 api files
        static async Task<bool> DoJSON(string summonerName)
        {
            _sem.WaitOne();
            string apikey = ConfigurationManager.AppSettings.Get("apikey");
            string nameinfo = summonerName;
            string path = ConfigurationManager.AppSettings.Get("path");
            var client = new HttpClient();

            Stream nameInfo = await client.GetStreamAsync("https://na.api.pvp.net/api/lol/na/v1.4/summoner/by-name/" + nameinfo + "?api_key=" + apikey);
            Thread.Sleep(1100);

            DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
            settings.UseSimpleDictionaryFormat = true;
            DataContractJsonSerializer userser = new DataContractJsonSerializer(typeof(Dictionary<string, Summoner>), settings);
            Dictionary<string, Summoner> userDict = (Dictionary<string, Summoner>)userser.ReadObject(nameInfo);

            string key = userDict.Keys.First<string>();
            id = userDict[key].id;

            leaguedata.LocalFileGen files = new leaguedata.LocalFileGen();
            if (!File.Exists(path + "champs.txt"))
            {
                int x = await files.ChampInfoFile();
            }
            if (!File.Exists(path + "history" + nameinfo + ".txt"))
            {
                int x = await files.MatchHistoryFile(nameinfo, id);
            }
            leaguedata.leagueDictionaries dicts = new leaguedata.leagueDictionaries();
            Dictionary<int, string> champIDtoName = dicts.getCIDtoCName();
            List<Match> matches = dicts.getMatchList(nameinfo);
            int y = await files.MatchInfoFile(nameinfo, matches, champIDtoName);
            _sem.Release();
            return true;
        }

 public static async Task<Stream> GetResponseStreamAsync(string url,
     IEnumerable<KeyValuePair<string, string>> headers = null, RequestHttpMethod method = RequestHttpMethod.Get)
 {
     if (string.IsNullOrWhiteSpace(url))
         throw new ArgumentNullException(nameof(url));
     var httpClient = new HttpClient();
     switch (method)
     {
         case RequestHttpMethod.Get:
             if (headers != null)
             {
                 foreach (var header in headers)
                 {
                     httpClient.DefaultRequestHeaders.TryAddWithoutValidation(header.Key, header.Value);
                 }
             }
             return await httpClient.GetStreamAsync(url);
         case RequestHttpMethod.Post:
             FormUrlEncodedContent formContent = null;
             if (headers != null)
             {
                 formContent = new FormUrlEncodedContent(headers);
             }
             var message = await httpClient.PostAsync(url, formContent);
             return await message.Content.ReadAsStreamAsync();
         default:
             throw new NotImplementedException("That type of request is unsupported.");
     }
 }

 protected override void OnLoad(EventArgs e)
 {
     var client = new HttpClient();
     client.DefaultRequestHeaders.Add("ServiceBusAuthorization", this.sendToken);
     var image = client.GetStreamAsync(this.sendAddress + "/image").GetAwaiter().GetResult();
     this.pictureBox.Image = Image.FromStream(image);
 }

		public static async Task<string> GetSdkPathAsync()
		{
			string result = Environment.GetEnvironmentVariable("DART_SDK", EnvironmentVariableTarget.Process);
			if (!Directory.Exists(result))
			{
				string extensionName = "DartVS";
				string extensionVersion = AssemblyInfo.AssemblyInformationalVersion;
				string tempDir = Path.Combine(Path.GetTempPath(), string.Format("{0}-{1}-sdk", extensionName, extensionVersion));
				result = Path.Combine(tempDir, "dart-sdk");
				if (!Directory.Exists(result))
				{
					// TODO: This code might have issues if two threads ask or the SDK at the same time and we need to download it...
					// Thread1 will start the download.
					// Thread2 will skip this code (DirectoryExists; unless we're very unlucky with timing), then crash on
					// the File.Exists check for dart.exe.

					Directory.CreateDirectory(tempDir);
					string sdkName = "dartsdk-windows-ia32-release.zip";
					string compressed = Path.Combine(tempDir, sdkName);

					using (var httpClient = new HttpClient())
					using (var stream = await httpClient.GetStreamAsync(RemoteSdkZipUrl).ConfigureAwait(false))
					using (var outputStream = File.OpenWrite(compressed))
						await stream.CopyToAsync(outputStream).ConfigureAwait(false);

					ZipFile.ExtractToDirectory(compressed, tempDir);
				}
			}

			if (!Directory.Exists(result) || !File.Exists(Path.Combine(result, "bin", "dart.exe")))
				throw new NotSupportedException("Could not locate or download the Dart SDK. All analysis is disabled.");

			return result;
		}

        /// <summary>
        /// Get basic user info
        /// </summary>
        /// <param name="user_id"></param>
        /// <returns></returns>
        public static async Task getUser(string user_id)
        {
            string baseURL = App.baseURL;
            HttpClient client = new HttpClient();

            if (App.logged_in == false && user_id == "__SELF__")    
            {
                // error if trying to access the logged in user and there is none
                return;
            }
            else if(App.logged_in == false)     // not logged in
            {
                baseURL = string.Format("{0}/users/{1}", baseURL, user_id);
            }
            else if(App.logged_in == true)      // logged in
            {
                baseURL = string.Format("{0}/users/{1}", baseURL, user_id);
                List<Parameter> parameters = new List<Parameter>();
                baseURL = AuthenticationAccess.addAuthentication(baseURL, parameters);
            }

            try
            {
                var jsonStream = await client.GetStreamAsync(baseURL);
                //var jsonString = await client.GetStringAsync(baseURL);
            }
            catch
            {

            }

            return;
        }

        public string PullHtml(string url)
        {
            var client = new HttpClient();
            var urlStreamTask = client.GetStreamAsync(url);
            var responseTask = urlStreamTask.ContinueWith(response => {
                if (response.Exception != null) {
                    throw response.Exception;
                }

                using (var memoryStream = new MemoryStream()) {
                    response.Result.CopyTo(memoryStream);
                    //默认按utf8编码读取html
                    string html = ReadHtml(memoryStream, Encoding.UTF8);

                    //根据html的charset判断编码类型
                    Match charSetMatch = Regex.Match(html, "charset=(?<code>[a-zA-Z0-9_-]+)", RegexOptions.IgnoreCase);
                    string chartSet = charSetMatch.Groups["code"].Value;
                    if (!string.IsNullOrEmpty(chartSet) && !chartSet.Equals("utf-8", StringComparison.OrdinalIgnoreCase)) {
                        html = ReadHtml(memoryStream, Encoding.GetEncoding(chartSet));
                    }

                    return html;
                }
            });

            return responseTask.Result;
        }

        public async Task<BitmapImage> GetBijinPicture(string Path)
        {
            var date = DateTime.Now;
            var url = "http://www.bijint.com/" + Path + "/tokei_images/" + date.ToString("HHmm") + ".jpg";

            HttpClient client = new HttpClient();
            client.DefaultRequestHeaders.Referrer = new Uri("http://www.bijint.com/" + Path);
            BitmapImage bitmap;
            using (var strm = await client.GetStreamAsync(new Uri(url)))
            {
                // BitmapImageインスタンスへはStream型をそのまま読み込ませることができないため、
                // InMemoryRandomAccessStreamへソースストリームをコピーする
                InMemoryRandomAccessStream ims = new InMemoryRandomAccessStream();
                var output = ims.GetOutputStreamAt(0);
                await RandomAccessStream.CopyAsync(strm.AsInputStream(), output);

                // BitmapImageへソースを設定し、Imageコントロールで表示させる
                bitmap = new BitmapImage();
                bitmap.SetSource(ims);
            }
            return bitmap;

            //var html = await client.GetStringAsync("http://www.bijint.com/kobe/cache/" + date.ToString("HHmm") + ".html");
            //this.html.NavigateToString(html);
        }

        private static Task<string> GetInfoAsync(string uri)
        {
            TaskCompletionSource<string> tcs = new TaskCompletionSource<string>();
            var client = new HttpClient();
            var streamTask = client.GetStreamAsync(uri);

            streamTask.ContinueWith(
                _ =>
                {
                    if (streamTask.IsCompleted)
                    {
                        var result = streamTask.Result;
                        var stringResult = new StreamReader(result).ReadToEnd();
                        tcs.TrySetResult(stringResult);
                    }
                    else
                    {
                        if (streamTask.IsCanceled)
                        {
                            tcs.TrySetCanceled();
                        }
                        else
                        {
                            tcs.TrySetException(streamTask.Exception.InnerExceptions);
                        }
                    }
                }
            );

            return tcs.Task;
        }

		public static async Task<Stream> GetImageStreamAsync(CameraModel camera)
		{
			var http = new HttpClient();
			http.DefaultRequestHeaders.Authorization = GetAuthenticationHeader(camera);

			return await http.GetStreamAsync(camera.Url);
		}

        private async void GetBijinPicture()
        {
            var date = DateTime.Now;
            var url = "http://www.bijint.com/jp/tokei_images/" + date.ToString("HHmm") + ".jpg";

            HttpClient client = new HttpClient();
            client.DefaultRequestHeaders.Referrer = new Uri("http://www.bijint.com/jp/");
            using (var strm = await client.GetStreamAsync(new Uri(url)))
            {
                // BitmapImageインスタンスへはStream型をそのまま読み込ませることができないため、
                // InMemoryRandomAccessStreamへソースストリームをコピーする
                InMemoryRandomAccessStream ims = new InMemoryRandomAccessStream();
                var output = ims.GetOutputStreamAt(0);
                await RandomAccessStream.CopyAsync(strm.AsInputStream(), output);

                // BitmapImageへソースを設定し、Imageコントロールで表示させる
                var bitmap = new BitmapImage();
                bitmap.SetSource(ims);
                image.Source = bitmap;

                // Save用にbyte配列に保存
                ims.Seek(0);
                imageBuffer = new byte[ims.Size];
                IBuffer ibuffer = imageBuffer.AsBuffer();
                await ims.ReadAsync(ibuffer, (uint)ims.Size, InputStreamOptions.None);
            }
        }