C# Http.StringContent类代码示例

        public void sendPost()
        {
            // Définition des variables qui seront envoyés
            HttpContent stringContent1 = new StringContent(param1String); // Le contenu du paramètre P1
            HttpContent stringContent2 = new StringContent(param2String); // Le contenu du paramètre P2
            HttpContent fileStreamContent = new StreamContent(paramFileStream);
            //HttpContent bytesContent = new ByteArrayContent(paramFileBytes);

            using (var client = new HttpClient())
            using (var formData = new MultipartFormDataContent())
            {
                formData.Add(stringContent1, "P1"); // Le paramètre P1 aura la valeur contenue dans param1String
                formData.Add(stringContent2, "P2"); // Le parmaètre P2 aura la valeur contenue dans param2String
                formData.Add(fileStreamContent, "FICHIER", "RETURN.xml");
                //  formData.Add(bytesContent, "file2", "file2");
                try
                {
                    var response = client.PostAsync(actionUrl, formData).Result;
                    MessageBox.Show(response.ToString());
                    if (!response.IsSuccessStatusCode)
                    {
                        MessageBox.Show("Erreur de réponse");
                    }
                }
                catch (Exception Error)
                {
                    MessageBox.Show(Error.Message);
                }
                finally
                {
                    client.CancelPendingRequests();
                }
            }
        }

        public async Task<JObject> Execute()
        {
            if (!NetworkInterface.GetIsNetworkAvailable())
                throw new Exception("Network is not available.");

            var uri = GetFullUri(_parameters);
            var request = WebRequest.CreateHttp(uri);
            request.Method = _method;

            Debug.WriteLine("Invoking " + uri);

            JObject response = null;

            var httpClient = new HttpClient();

            if (_method == "GET")
            {
                HttpResponseMessage responseMessage = await httpClient.GetAsync(uri);
                string content = await responseMessage.Content.ReadAsStringAsync();
                if (!string.IsNullOrEmpty(content))
                    response = JObject.Parse(content);
            }
            else if (_method == "POST")
            {
                var postContent = new StringContent(_postParameters.ConstructQueryString());
                postContent.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
                HttpResponseMessage responseMessage = await httpClient.PostAsync(uri, postContent);
                string content = await responseMessage.Content.ReadAsStringAsync();
                if (!string.IsNullOrEmpty(content))
                    response = JObject.Parse(content);
            }

            return response;
        }

        public Task<string> Request(ApiClientRequest request)
        {
            if (request == null) throw new ArgumentNullException(nameof(request));
            if (string.IsNullOrWhiteSpace(request.Username)) throw new ArgumentException("Username is required", nameof(request));
            if (string.IsNullOrWhiteSpace(request.Password)) throw new ArgumentException("Password is required", nameof(request));
            if (string.IsNullOrWhiteSpace(request.BaseAddress)) throw new ArgumentException("BaseAddress is required", nameof(request));
            if (string.IsNullOrWhiteSpace(request.RequestUri)) throw new ArgumentException("RequestUri is required", nameof(request));
            if (string.IsNullOrWhiteSpace(request.Content)) throw new ArgumentException("Content is required", nameof(request));

            using (var httpClient = CreateHttpClient(request.Username, request.Password, request.BaseAddress))
            using (var content = new StringContent(request.Content, Encoding.UTF8, "application/soap+xml"))
            {
                var response = httpClient.PostAsync(request.RequestUri, content).Result;

                if (!response.IsSuccessStatusCode)
                {
                    var error = response.Content.ReadAsStringAsync().Result;

                    throw new InvalidOperationException($"{error} ({response.StatusCode} {response.ReasonPhrase})");
                }

                return response
                   .Content
                   .ReadAsStringAsync();
            }
        }

 public static HttpResponseMessage CreateInvalidGrantTokenResponseMessage()
 {
     HttpResponseMessage responseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest);
     HttpContent content = new StringContent("{\"error\":\"invalid_grant\",\"error_description\":\"AADSTS70002: Error validating credentials.AADSTS70008: The provided access grant is expired or revoked.Trace ID: f7ec686c-9196-4220-a754-cd9197de44e9Correlation ID: 04bb0cae-580b-49ac-9a10-b6c3316b1eaaTimestamp: 2015-09-16 07:24:55Z\",\"error_codes\":[70002,70008],\"timestamp\":\"2015-09-16 07:24:55Z\",\"trace_id\":\"f7ec686c-9196-4220-a754-cd9197de44e9\",\"correlation_id\":\"04bb0cae-580b-49ac-9a10-b6c3316b1eaa\"}");
     responseMessage.Content = content;
     return responseMessage;
 }

        private static void SendSampleData()
        {
            try {

                var sampleData = new
                {
                    value = "Sending some test info" + DateTime.Now.ToString()
                };

                HttpClient httpClient = new HttpClient();
                httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                var data = string.Format("Sending data on {0}", DateTime.Now.ToLongTimeString());

                var jsonData = string.Format("{{'sender': '{0}', 'message': '{1}' }}", Environment.MachineName, data);

                var stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");

                HttpResponseMessage response = null;
                response = httpClient.PostAsync(ConfigurationManager.AppSettings["serverAdress"] + "/api/data", stringContent).Result;

                if (response.IsSuccessStatusCode)
                {
                    Console.WriteLine("Post succesful, StatusCode: " + response.StatusCode);
                }
                else
                {
                    Console.WriteLine("Post failed, StatusCode: " + response.StatusCode);
                }
            }
            catch (Exception ex)
            {
                Console.Write(ex.Message + ex.StackTrace);
            }
        }

        public async Task<bool> AddToFavorite(Recipe r)
        {
            try
            {
                string json = JsonConvert.SerializeObject(r);
                HttpContent content = new StringContent(json, Encoding.UTF8, "application/json");
                HttpResponseMessage response = await client.PostAsync("api/recipes", content);
                if ((response.IsSuccessStatusCode) || (response.StatusCode.ToString().Equals("Conflict")))
                {
                    String recipeId = r.recipe_id + currentApp.GlobalInstance.userId;
                    UserFavorite uFav = new UserFavorite(recipeId, currentApp.GlobalInstance.userId, r.recipe_id);
                    string jsonfav = JsonConvert.SerializeObject(uFav);
                    HttpContent contentfav = new StringContent(jsonfav, Encoding.UTF8, "application/json");
                    HttpResponseMessage responsefav = await client.PostAsync("api/userfavorites", contentfav);
                    if (responsefav.IsSuccessStatusCode)
                    {
                        return true;
                    }
                    return false;
                }
            }
            catch (HttpRequestException e) {
                return false;
            }

            return false;
        }

        // ReSharper disable once InconsistentNaming
        public async void Controller_Can_POST_a_new_Registerd_User()
        {
            using (var client = new HttpClient())
            {
                // Arrange
                client.BaseAddress = new Uri(UrlBase);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
           

                // Manually set "content-type" header to reflect serialized data format.
                var settings = new JsonSerializerSettings();
                var ser = JsonSerializer.Create(settings);
                var j = JObject.FromObject(_registration, ser);
                HttpContent content = new StringContent(j.ToString());
                content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                

                // Act
                // PostAsJsonAsync(), per MS recommendation, however results in problem of RegisterAsync() accepting payload: content type?
                // Serialized registration data is now associated with HttpContent element explicitly, with format then set.
                var response = await client.PostAsync(client.BaseAddress + "/RegisterAsync", content); 
                //var response = await client.PostAsJsonAsync(client.BaseAddress + "/RegisterAsync", _registration); // error
                
                // Assert
                Assert.IsTrue(response.StatusCode == HttpStatusCode.Created);
                Assert.IsTrue(response.IsSuccessStatusCode);
                
            }
        }

        private async void AppBarButton_Click(object sender, RoutedEventArgs e)
        {
            HttpClient httpClient = new HttpClient();
            httpClient.BaseAddress = new Uri(ip);
            models.Autenticacao a = new models.Autenticacao
            {
                Login = login.Text,
                Senha = senha.Text
            };

            string s = "=" + JsonConvert.SerializeObject(a);

            var content = new StringContent(s, Encoding.UTF8,
            "application/x-www-form-urlencoded");

            var response =  await httpClient.PostAsync("/api/user/login", content);

            var str = response.Content.ReadAsStringAsync().Result;

            str = "OK";

            if (str == "OK")
            {
                this.Frame.Navigate(typeof(MainPage));
            }
        }

        public async Task<OperationResult<PageResult<product>>> GetHighwaveProduct(string accessToken, string[] brands, DateTime start, DateTime? end = null, int pageIndex = 1, int pageSize = 20)
        {
            string requestUrl = string.Format(url + @"/highwave/GetProduct?pageIndex={0}&pageSize={1}", pageIndex, pageSize);

            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(authorizationScheam, accessToken);

            var postString = new StringContent(JsonConvert.SerializeObject(new { brands = brands, start = start, end = end }));

            postString.Headers.ContentType.MediaType = contentType;

            var result = await client.PostAsync(requestUrl, postString);

            if (result.StatusCode != HttpStatusCode.OK)
            {
                var errorStr = await result.Content.ReadAsStringAsync();

                var error = JsonConvert.DeserializeObject<OperationResult>(errorStr);

                return new OperationResult<PageResult<Models.product>>() { err_code = error.err_code, err_info = error.err_info };
            }

            var Json = result.Content.ReadAsStringAsync().Result;

            PageResult<product> product = JsonConvert.DeserializeObject<PageResult<product>>(Json);

            return new OperationResult<PageResult<product>>() { err_code = ErrorEnum.success, err_info = ErrorEnum.success.ToString(), entity = product };
        }

        /// <summary>
        /// Send events to Seq.
        /// </summary>
        /// <param name="events">The buffered events to send.</param>
        protected override void SendBuffer(LoggingEvent[] events)
        {
            if (ServerUrl == null)
                return;

            var payload = new StringWriter();
            payload.Write("{\"events\":[");
            LoggingEventFormatter.ToJson(events, payload);
            payload.Write("]}");

            var content = new StringContent(payload.ToString(), Encoding.UTF8, "application/json");
            if (!string.IsNullOrWhiteSpace(ApiKey))
                content.Headers.Add(ApiKeyHeaderName, ApiKey);

            var baseUri = ServerUrl;
            if (!baseUri.EndsWith("/"))
                baseUri += "/";

            using (var httpClient = new HttpClient { BaseAddress = new Uri(baseUri) })
            {
                var result = httpClient.PostAsync(BulkUploadResource, content).Result;
                if (!result.IsSuccessStatusCode)
                    ErrorHandler.Error(string.Format("Received failed result {0}: {1}", result.StatusCode, result.Content.ReadAsStringAsync().Result));
            }
        }

        private static string MakeResourcePutRequest(string resourceName)
        {
            using (HttpClient httpClient = new HttpClient())
            {
                httpClient.BaseAddress = new Uri(BridgeBaseAddress);
                var content = new StringContent(
                        string.Format(@"{{ name : ""{0}"" }}", resourceName),
                        Encoding.UTF8,
                        "application/json");
                try
                {
                    var response = httpClient.PutAsync("/resource/", content).Result;
                    if (!response.IsSuccessStatusCode)
                        throw new Exception("Unexpected status code: " + response.StatusCode);

                    var responseContent = response.Content.ReadAsStringAsync().Result;
                    var match = regexResource.Match(responseContent);
                    if (!match.Success || match.Groups.Count != 2)
                        throw new Exception("Invalid response from bridge: " + responseContent);

                    return match.Groups[1].Value;
                }
                catch (Exception exc)
                {
                    throw new Exception("Unable to start resource: " + resourceName, exc);
                }
            }
        }

 private static void MakeConfigRequest()
 {
     using (HttpClient httpClient = new HttpClient())
     {
         httpClient.BaseAddress = new Uri(BridgeBaseAddress);
         var content = new StringContent(
             CreateConfigRequestContentAsJson(),
             Encoding.UTF8,
             "application/json");
         try
         {
             var response = httpClient.PostAsync("/config/", content).GetAwaiter().GetResult();
             if (!response.IsSuccessStatusCode)
             {
                 string reason = String.Format("{0}Bridge returned unexpected status code='{1}', reason='{2}'",
                                             Environment.NewLine, response.StatusCode, response.ReasonPhrase);
                 if (response.Content != null)
                 {
                     string contentAsString = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
                     reason = String.Format("{0}, content:{1}{2}",
                                             reason, Environment.NewLine, contentAsString);
                 }
                 throw new Exception(reason);
             }
             _BridgeStatus = BridgeState.Started;
         }
         catch (Exception exc)
         {
             _BridgeStatus = BridgeState.Faulted;
             throw new Exception("Bridge is not running", exc);
         }
     }
 }

 private static void MakeConfigRequest()
 {
     using (HttpClient httpClient = new HttpClient())
     {
         httpClient.BaseAddress = new Uri(BridgeBaseAddress);
         string resourceFolder = TestProperties.GetProperty(TestProperties.BridgeResourceFolder_PropertyName);
         string contentPayload = "{ resourcesDirectory : \"" + resourceFolder + "\" }"; 
         var content = new StringContent(
             contentPayload,
             Encoding.UTF8,
             "application/json");
         try
         {
             var response = httpClient.PostAsync("/config/", content).Result;
             if (!response.IsSuccessStatusCode)
                 throw new Exception("Unexpected status code: " + response.StatusCode);
             _BridgeStatus = BridgeState.Started;
         }
         catch (Exception exc)
         {
             _BridgeStatus = BridgeState.Faulted;
             throw new Exception("Bridge is not running", exc);
         }
     }
 }

        public void ProcessBatchAsync_CallsRegisterForDispose()
        {
            List<IDisposable> expectedResourcesForDisposal = new List<IDisposable>();
            MockHttpServer server = new MockHttpServer(request =>
            {
                var tmpContent = new StringContent(String.Empty);
                request.RegisterForDispose(tmpContent);
                expectedResourcesForDisposal.Add(tmpContent);
                return new HttpResponseMessage { Content = new StringContent(request.RequestUri.AbsoluteUri) };
            });
            UnbufferedODataBatchHandler batchHandler = new UnbufferedODataBatchHandler(server);
            HttpRequestMessage batchRequest = new HttpRequestMessage(HttpMethod.Post, "http://example.com/$batch")
            {
                Content = new MultipartContent("mixed")
                {
                    ODataBatchRequestHelper.CreateODataRequestContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
                    new MultipartContent("mixed") // ChangeSet
                    {
                        ODataBatchRequestHelper.CreateODataRequestContent(new HttpRequestMessage(HttpMethod.Post, "http://example.com/"))
                    }
                }
            };

            var response = batchHandler.ProcessBatchAsync(batchRequest, CancellationToken.None).Result;
            var resourcesForDisposal = batchRequest.GetResourcesForDisposal();

            foreach (var expectedResource in expectedResourcesForDisposal)
            {
                Assert.Contains(expectedResource, resourcesForDisposal);
            }
        }

        /// <summary>
        /// Sets the content of the request by the given body and the the required GZip configuration.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="service">The service.</param>
        /// <param name="body">The body of the future request. If <c>null</c> do nothing.</param>
        /// <param name="gzipEnabled">
        /// Indicates if the content will be wrapped in a GZip stream, or a regular string stream will be used.
        /// </param>
        internal static void SetRequestSerailizedContent(this HttpRequestMessage request,
            IClientService service, object body, bool gzipEnabled)
        {
            if (body == null)
            {
                return;
            }
            HttpContent content = null;

            var mediaType = "application/" + service.Serializer.Format;
            var serializedObject = service.SerializeObject(body);
            if (gzipEnabled)
            {
                content = CreateZipContent(serializedObject);
                content.Headers.ContentType = new MediaTypeHeaderValue(mediaType)
                {
                    CharSet = Encoding.UTF8.WebName
                };
            }
            else
            {
                content = new StringContent(serializedObject, Encoding.UTF8, mediaType);
            }

            request.Content = content;
        }