C# HttpClient.PutAsJsonAsync方法代码示例

 public ContactsDto Update(ContactsDto contactsDto)
 {
     using (var client = new HttpClient())
     {
         HttpResponseMessage response =
             client.PutAsJsonAsync("http://localhost:9372/api/ContactsApi/"+ contactsDto.Id, contactsDto).Result;
         return response.Content.ReadAsAsync<ContactsDto>().Result;
     }
 }

        public async void GetLocation()
        {
            Geoposition pos = await _geolocator.GetGeopositionAsync();
            var pin = new MapIcon()
            {
                Location = pos.Coordinate.Point,
                Title = "You are here!",
                Image = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Image/Location_Icon.png")),
                NormalizedAnchorPoint = new Point() { X = 0.32, Y = 0.78 },
            };
            map.MapElements.Add(pin);
            await map.TrySetViewAsync(pos.Coordinate.Point, 15);
            (App.Current as App).User.user_x = pos.Coordinate.Point.Position.Latitude.ToString();
            (App.Current as App).User.user_y = pos.Coordinate.Point.Position.Longitude.ToString();
            using (var client = new HttpClient())
            {
                try
                {
                    client.BaseAddress = new Uri(@"http://pubbus-coeus.azurewebsites.net/");
                    client.DefaultRequestHeaders.Accept.Clear();
                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    HttpResponseMessage response = await client.PutAsJsonAsync("api/users/" + (App.Current as App).User.user_id, (App.Current as App).User);

                    //Printf("Da cap nhat vi tri: " + (App.Current as App).User.user_x + ":" + (App.Current as App).User.user_y);
                }
                catch (Exception ex)
                {
                    Printf(ex.Message);
                }
            }
        }

 static bool UpdateProduct(ProductViewModel newProduct)
 {
     HttpClient client = new HttpClient();
     client.BaseAddress = new Uri(baseURL);
     var response = client.PutAsJsonAsync("api/Products/", newProduct).Result;
     client.Dispose();
     return response.Content.ReadAsAsync<bool>().Result;
 }

 public Rating Update(Rating Rating)
 {
     using (var client = new HttpClient())
     {
         HttpResponseMessage response =
             client.PutAsJsonAsync("http://localhost:17348/api/Rating/" + Rating.Id, Rating).Result;
         return response.Content.ReadAsAsync<Rating>().Result;
     }
 }

 public Company Update(Company company)
 {
     using (var client = new HttpClient())
     {
         HttpResponseMessage response =
             client.PutAsJsonAsync("http://localhost:17348/api/company/" + company.Id, company).Result;
         return response.Content.ReadAsAsync<Company>().Result;
     }
 }

        public void Main(string[] args)
        {
            var config = new Configuration().AddEnvironmentVariables();
            string urlOptimizer = config.Get("URLOptimizerJobs") ?? "http://localhost:5004/api/Jobs/";
            Console.WriteLine("Mortgage calculation service listening to {0}", urlOptimizer);

            bool WarnNoMoreJobs = true;
            while (true)
            {
                try
                {
                    var httpClient = new HttpClient();
                    httpClient.DefaultRequestHeaders.Accept.Clear();
                    httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    List<Job> jobs = httpClient.GetAsync(urlOptimizer).Result.Content.ReadAsAsync<List<Job>>().Result;

                    List<Job> remainingJobs = jobs.FindAll(j => !j.Taken);
                    if (remainingJobs.Count == 0)
                    {
                        if (WarnNoMoreJobs)
                        {
                            Console.WriteLine("No more jobs !");
                            WarnNoMoreJobs = false;
                        }
                        Task.Delay(1000).Wait();
                        continue;
                    }
                    else
                    {
                        Console.WriteLine("{0} job(s) remaining", remainingJobs.Count);
                        WarnNoMoreJobs = true;
                    }
                    Random engine = new Random(DateTime.Now.Millisecond);
                    Job Taken = remainingJobs[engine.Next(remainingJobs.Count)];
                    Taken.Taken = true;
                    httpClient.PutAsJsonAsync<Job>(urlOptimizer + Taken.Id, Taken).Result.EnsureSuccessStatusCode();

                    // The calculation is completely simulated, and does not correspond to any real financial computing
		    // We thus only wait for a given delay and send a random amount for the total cost
		    // Should one be interested in the kind of computation that can truly use scaling, one can take a look
		    // at the use of Genetic Algorithms as shown as in https://github.com/jp-gouigoux/PORCAGEN
                    Task.Delay(20).Wait();
                    Taken.Done = true;
                    Taken.TotalMortgageCost = Convert.ToDecimal(engine.Next(1000));

                    httpClient.PutAsJsonAsync<Job>(urlOptimizer + Taken.Id, Taken).Result.EnsureSuccessStatusCode();
                }
                catch
                {
                    Task.Delay(1000).Wait();
                }
            }
        }

 public ActionResult AddFinance(SearchFinanceModel model)
 {
     Session["Finance"] = null;
     IEnumerable<FinanceModel> objBE;
     using (var client = new HttpClient())
     {
         model.addFinance.insertUserId = base.CurrentUserID;
         client.BaseAddress = new Uri(System.Configuration.ConfigurationManager.AppSettings["APIURI"]);
         client.DefaultRequestHeaders.Accept.Add(
             new MediaTypeWithQualityHeaderValue("application/json"));
         HttpResponseMessage response = client.PutAsJsonAsync("finance/SaveFinanceActivity", model.addFinance).Result;
         if (response.IsSuccessStatusCode)
         {
             string jsonResult = response.Content.ReadAsStringAsync().Result;
             if (!string.IsNullOrEmpty(jsonResult) && !jsonResult.Equals("[]"))
             {
                 objBE = JsonConvert.DeserializeObject<IEnumerable<FinanceModel>>(jsonResult);
                 model.addFinance.finance = objBE;
             }
             else
                 model.addFinance.finance = null;
         }
         model.activityType = (IEnumerable<SelectListItem>)Session["ActivityType"];
         model.processorCompany = (IEnumerable<SelectListItem>)Session["Processor"];
         model.addFinance.activityType = (IEnumerable<SelectListItem>)Session["ActivityType"];
         model.addFinance.processorCompany = (IEnumerable<SelectListItem>)Session["Processor"];
         ViewBag.SuccessMsg = Pecuniaus.Resources.Finance.Finance.FinanceAddedSuccessfully;
     }
     return View("Index", model);
 }

        public void User_Is_Added_To_Queue()
        {
            var client = new HttpClient();

            string name = "hello";
            string key = Convert.ToString(Guid.NewGuid());
            string format = "https://qcue-live.firebaseio.com/queues/{0}/{1}.json";

            string uri = String.Format(format, key, name);

            var queue = new Q
            {
                ShortCode = "TEST",
                Users = new Dictionary<string, QUser>
                 {
                    {
                        Convert.ToString(Guid.NewGuid()),
                        new QUser
                        {
                            Id = "red",
                            State = "waiting"
                        }
                    }
                 }
            };

            var json = JsonConvert.SerializeObject(queue);
            var result = client.PutAsJsonAsync(uri, queue).Result;

            result.EnsureSuccessStatusCode();
        }

        /// <summary>
        /// Runs an HttpClient issuing a POST request against the controller.
        /// </summary>
        static async void RunClient()
        {
            var handler = new HttpClientHandler();
            handler.Credentials = new NetworkCredential("Boris", "xyzxyz");
            var client = new System.Net.Http.HttpClient(handler);

            var bizMsgDTO = new BizMsgDTO
            {
                Name = "Boris",
                Date = DateTime.Now,
                User = "Boris.Momtchev",
            };

            // *** POST/CREATE BizMsg
            Uri address = new Uri(_baseAddress, "/api/BizMsgService");
            HttpResponseMessage response = await client.PostAsJsonAsync(address.ToString(), bizMsgDTO);

            // Check that response was successful or throw exception
            // response.EnsureSuccessStatusCode();

            // BizMsg result = await response.Content.ReadAsAsync<BizMsg>();
            // Console.WriteLine("Result: Name: {0}, Date: {1}, User: {2}, Id: {3}", result.Name, result.Date.ToString(), result.User, result.Id);
            Console.WriteLine(response.StatusCode + " - " + response.Headers.Location);

            // *** PUT/UPDATE BizMsg
            var testID = response.Headers.Location.AbsolutePath.Split('/')[3];
            bizMsgDTO.Name = "Boris Momtchev";
            response = await client.PutAsJsonAsync(address.ToString() + "/" + testID, bizMsgDTO);
            Console.WriteLine(response.StatusCode);

            // *** DELETE BizMsg
            response = await client.DeleteAsync(address.ToString() + "/" + testID);
            Console.WriteLine(response.StatusCode);
        }

        public async Task<IEnumerable<Event>> ProcessAsync(Event evnt)
        {
            var importRecordExtracted = evnt.GetBody<ImportRecordExtracted>();
            var elasticSearchUrl = _configurationValueProvider.GetValue(Constants.ElasticSearchUrlKey);

            var client = new HttpClient();
            var url = string.Format("{0}/import/{1}/{2}", elasticSearchUrl,
                importRecordExtracted.IndexType,
                importRecordExtracted.Id);
            var responseMessage = await client.PutAsJsonAsync(url, importRecordExtracted);

           if (!responseMessage.IsSuccessStatusCode)
            {
                throw new ApplicationException("Indexing failed. " 
                    + responseMessage.ToString());
            }

            return new[]
            {
                new Event(new NewIndexUpserted()
                {
                    IndexUrl = url
                }) 
            };
        }

        public async Task AddActivityGoal()
        {
            var session = await Login();
            var currentSeed = Guid.NewGuid();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id);

                var form = new Activity { Name = $"Name.{currentSeed}", Description = $"Description.{currentSeed}" };

                // Add Activity with valid data
                var activityResponse = await client.PostAsJsonAsync($"/api/activities", form);
                Assert.Equal(HttpStatusCode.Created, activityResponse.StatusCode);

                var activity = await activityResponse.Content.ReadAsJsonAsync<Activity>();
                Assert.Equal($"Name.{currentSeed}", activity.Name);

                var goalForm = new ActivityGoalForm { Description = $"Description.{currentSeed}" };
                activityResponse = await client.PutAsJsonAsync($"/api/activities/{activity.Id}/goal", goalForm);
                Assert.Equal(HttpStatusCode.OK, activityResponse.StatusCode);

                activity = await activityResponse.Content.ReadAsJsonAsync<Activity>();
                Assert.Equal(1, activity.Goals.Count);
            }
        }

        static async Task RunAsync_Update()
        {
            using (var client = new HttpClient())
            {
                client.BaseAddress = new Uri("http://localhost:2614/");
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                try
                {
                    VideoDTO video = new VideoDTO { title = "shen-demo" };
                    HttpResponseMessage response = await client.PutAsJsonAsync("Videoes/ca161757-8196-4454-ae26-d0d70e9cb679", video);
                    response.EnsureSuccessStatusCode();

                    if (response.IsSuccessStatusCode)
                    {
                        VideoDTO videoDTO = await response.Content.ReadAsAsync<VideoDTO>();
                    }
                }
                catch (Exception ex)
                {
                    Console.Write(ex.Message);
                }

            }
        }

 private async void sendReservationDataEdit()
 {
     HttpClient client = new HttpClient();
     string URL = "http://92.221.124.167";
     client.BaseAddress = new Uri(URL);
     HttpResponseMessage response = await client.PutAsJsonAsync("/rest/edit/reservation", reservation).ContinueWith((postTask) => postTask.Result.EnsureSuccessStatusCode());
     this.Close();
 }

 public void Update(Customer cus)
 {
     using (var client = new HttpClient())
     {
         HttpResponseMessage response =
             client.PutAsJsonAsync(ServerAddress.Address + "customer/", cus).Result;
     }
 }

 public void Update(Login login)
 {
     using (var client = new HttpClient())
     {
         HttpResponseMessage response =
             client.PutAsJsonAsync(ServerAddress.Address + "login/", login).Result;
     }
 }