|
public PutAsync ( Uri requestUri, HttpContent content ) : Task |
||
| requestUri | Uri | |
| content | HttpContent | |
| return | Task |
|
private static async Task AlbumsControllerTest(HttpClient client)
{
// create album
await client.PostAsync("Albums/Create",
new FormUrlEncodedContent(new[] { new KeyValuePair<string, string>("title", "album 009") }));
await client.PostAsync("Albums/Create",
new FormUrlEncodedContent(new[] { new KeyValuePair<string, string>("title", "album 010") }));
// get all albums
Console.WriteLine(await client.GetStringAsync("Albums/All"));
// update album
await client.PutAsync("Albums/Update",
new FormUrlEncodedContent(new[]
{
new KeyValuePair<string, string>("id", "2"),
new KeyValuePair<string, string>("year", "2014"),
new KeyValuePair<string, string>("producer", "gosho ot pochivka")
}));
// delete album
await client.DeleteAsync("Albums/Delete/1");
// add song to album
await client.PutAsync("Albums/AddSong?albumId=2&songId=2", null);
// add artist to album
await client.PutAsync("Albums/AddArtist?albumId=2&artistId=2", null);
}
private static async Task SendEmployee(Employee employee, string dataFormat, int portNumber)
{
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Clear();
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("DataUpdatePort", portNumber.ToString());
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", dataFormat);
// Construct the request.
string url = "http://*****:*****@"Employee with ID = " + employee.EmployeeId + "was sent to the DataWarehouse.");
}
else
{
Console.WriteLine(@"Warning: Unable to send employee with ID = " + employee.EmployeeId + " to the DataWarehouse.");
}
}
}
public async Task<string> LightOnTask(Boolean on, int Id)
{
this.on = on;
string url = "http://" + ip + ":" + port + "/" + "api/" + username + "/" + "lights" + "/" + Id + "/" + "state";
HttpContent content;
if (on == true)
{
content = new StringContent
("{\"on\": true }",
Encoding.UTF8,
"application/json");
}
else {
content = new StringContent
("{\"on\": false}",
Encoding.UTF8,
"application/json");
}
using (HttpClient hc = new HttpClient())
{
var response = await hc.PutAsync(url, content);
response.EnsureSuccessStatusCode();
return await response.Content.ReadAsStringAsync();
}
}
public async System.Threading.Tasks.Task<HttpResponseMessage> Get(string url, string body, string contenttype)
{
using (var client = new HttpClient())
{
return await client.PutAsync(url, new StringContent(body, System.Text.Encoding.UTF8, contenttype));
}
}
private string Send(FileTransmission transmission, string basePath = null)
{
var path = basePath == null
? Path.GetFileName(transmission.Path)
: transmission.Path.Replace(basePath, string.Empty);
var uri = new Uri ("{0}/warpgate/io/{1}".Fmt(transmission.BaseUrl, path));
using (var file = File.OpenRead (transmission.Path)) {
var content = new StreamContent (file);
using (var client = new HttpClient ()) {
var upload = client.PutAsync (uri, content);
upload.Wait ();
var readContent = upload.Result.Content.ReadAsStringAsync ();
readContent.Wait ();
return readContent.Result;
}
}
}
private async void Button_Click_1(object sender, RoutedEventArgs e) {
var car = (Car)DataContext;
using (HttpClient httpClient = new HttpClient()) {
var jsonContent = new StringContent(
await JsonConvert.SerializeObjectAsync(car)
);
jsonContent.Headers.ContentType.MediaType = "application/json";
var response = await httpClient.PutAsync(
Constants.BASE_API_ADDRESS, jsonContent
);
try {
response.EnsureSuccessStatusCode();
} catch (Exception ex) {
MessageBox.Show(
string.Format(
"The request was not successful. Message: {0}", ex.Message
)
);
} finally {
this.Close();
}
}
}
public async void SendDataReglage(int idProfil, int idReglage, String temp, String humi, String duree = "-1", String enso = "-1")
{
ReglageViewModel r = new ReglageViewModel()
{
TemperatureInterieur = double.Parse(temp),
Humidite = double.Parse(humi),
Duree = int.Parse(duree),
Lumiere = double.Parse(enso),
};
string content = JsonConvert.SerializeObject(r);
var reponse = await httpc.PutAsync("/api/Reglage/" + idProfil + "/" + idReglage, new StringContent(content, Encoding.UTF8, "application/json"));
var t = reponse;
}
public async Task<HueResults> CreateOrUpdateSceneAsync(string id, string name, IEnumerable<string> lights)
{
CheckInitialized();
if (id == null)
throw new ArgumentNullException("id");
if (id.Trim() == String.Empty)
throw new ArgumentException("id must not be empty", "id");
if (lights == null)
throw new ArgumentNullException("lights");
dynamic jsonObj = new ExpandoObject();
jsonObj.lights = lights;
if (!string.IsNullOrEmpty(name))
jsonObj.name = name;
string jsonString = JsonConvert.SerializeObject(jsonObj);
HttpClient client = new HttpClient();
var response = await client.PutAsync(new Uri(String.Format("{0}scenes/{1}", ApiBase, id)), new StringContent(jsonString)).ConfigureAwait(false);
var jsonResult = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
return DeserializeDefaultHueResult(jsonResult);
}
public async Task<Result> PutData(Uri uri, StringContent json, UserAccountEntity userAccountEntity)
{
var httpClient = new HttpClient();
try
{
var authenticationManager = new AuthenticationManager();
if (userAccountEntity.GetAccessToken().Equals("refresh"))
{
await authenticationManager.RefreshAccessToken(userAccountEntity);
}
var user = userAccountEntity.GetUserEntity();
if (user != null)
{
var language = userAccountEntity.GetUserEntity().Language;
httpClient.DefaultRequestHeaders.Add("Accept-Language", language);
}
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", userAccountEntity.GetAccessToken());
var response = await httpClient.PutAsync(uri, json);
var responseContent = await response.Content.ReadAsStringAsync();
return response.IsSuccessStatusCode ? new Result(true, string.Empty) : new Result(false, responseContent);
}
catch (Exception)
{
return new Result(false, string.Empty);
}
}
private static async Task CreateServerAsync()
{
var httpClient = new HttpClient();
var serverConfiguration = new ServerConfiguration
{
DefaultStorageTypeName = "voron",
Port = Port,
RunInMemory = true,
Settings =
{
{ "Raven/ServerName", ServerName }
}
};
var response = await httpClient
.PutAsync("http://localhost:8585/servers", new JsonContent(RavenJObject.FromObject(serverConfiguration)))
.ConfigureAwait(false);
if (response.IsSuccessStatusCode == false)
throw new InvalidOperationException("Failed to start server.");
using (var stream = await response.GetResponseStreamWithHttpDecompression().ConfigureAwait(false))
{
var data = RavenJToken.TryLoad(stream);
if (data == null)
throw new InvalidOperationException("Failed to retrieve server url.");
ServerUrl = data.Value<string>("ServerUrl");
}
}
public async Task <bool> Update(string path, T entity)
{
var url = BaseUri + path;
using (System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient())
{
httpClient.BaseAddress = BaseUri;
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("utf-8"));
string endpoint = path;
try
{
var serialized = JsonConvert.SerializeObject(entity);
HttpContent content = new StringContent(serialized, Encoding.UTF8, "application/json");
System.Net.Http.HttpResponseMessage response = await httpClient.PutAsync(endpoint, content);
if (response.IsSuccessStatusCode)
{
string jsonResponse = await response.Content.ReadAsStringAsync();
//do something with json response here
}
}
catch (Exception)
{
return(false);
}
return(true);
}
}
public void It_can_get_and_set_composite_attribute_value_as_xml()
{
var client = new HttpClient();
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.netmx.attr+xml"));
string resultString = "";
client.GetStringAsync("http://*****:*****@"<MBeanAttribute><Value>{0}</Value></MBeanAttribute>",newXml), Encoding.UTF8, "application/vnd.netmx.attr+xml"))
.ContinueWith(x => x.Result.Content.ReadAsStringAsync().ContinueWith(y => resultString = y.Result).Wait())
.Wait();
resultObject = XElement.Parse(resultString);
valueElement = resultObject.Element("Value");
compositeElement = valueElement.Element("Composite");
Assert.AreEqual(compositeElement.Element("ID").Value, "3");
Assert.AreEqual(compositeElement.Element("Name").Value, "Joe");
}
/// <summary> This put async gets data from API according to our parameters we send in data. </summary>
/// <param name="uri"> The uri we are posting to </param>
/// <param name="data"> The data is the parameters we send in for filtering our data. </param>
/// <param name="token"> The token identifying who we are. </param>
/// <param name="header"> The type of header in our HTTP client. </param>
/// <typeparam name="TResult"> The result of the task </typeparam>
/// <returns> The result of the task is returned. <see cref="Task" />. </returns>
public async Task <TResult> PutAsync <TResult>(Uri uri, TResult data, CancellationToken cancellationToken, string token = "", string header = "")
{
HttpResponseMessage response;
using (System.Net.Http.HttpClient httpClient = CreateHttpClient(token))
{
if (!string.IsNullOrEmpty(header))
{
AddHeaderParameter(httpClient, header);
}
var content = new StringContent(JsonSerializer.Serialize(data));
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
response = await httpClient.PutAsync(uri, content, cancellationToken).ConfigureAwait(false);
content.Dispose();
}
await HandleResponse(response).ConfigureAwait(false);
string serialized = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var result = await Task.Run(() => JsonSerializer.Deserialize <TResult>(serialized, serializerSettings))
.ConfigureAwait(false);
return(result);
}
private static async Task CallAzureResourceManagerApi(string resourceManagementEndpoint, string subscriptionId, string header, string resourceGroupName)
{
var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", header);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
try
{
//register the subscription with DataFactory provider
StringContent body = new StringContent("", Encoding.UTF8, "application/json");
string endpoint = "{0}subscriptions/{1}/providers/Microsoft.DataFactory/register?api-version=2015-01-01";
string uri = String.Format(endpoint, resourceManagementEndpoint, subscriptionId);
HttpResponseMessage resp = await client.PostAsync(uri, body);
Console.WriteLine("registration status: {0}", resp.StatusCode);
// Resource Group API
//StringContent body = new StringContent("{\"location\":\"West US\",\"tags\":{}}", Encoding.UTF8, "application/json");
//string endpoint = "{0}subscriptions/{1}/resourcegroups/{2}?api-version=2014-04-01";
// ADF REST API
body = new StringContent("{\"location\":\"West US\",\"tags\":{}}", Encoding.UTF8, "application/json");
endpoint = "{0}subscriptions/{1}/resourcegroups/{2}/providers/Microsoft.DataFactory/datafactories/{3}?api-version=2014-10-01-preview";
uri = String.Format(endpoint, resourceManagementEndpoint, subscriptionId, resourceGroupName, dataFactoryName);
resp = await client.PutAsync(uri, body);
Console.WriteLine("creation status: {0}", resp.StatusCode);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public async System.Threading.Tasks.Task <ActionResult> StudentViewModels_Update([DataSourceRequest] DataSourceRequest request, [Bind(Prefix = "models")] IEnumerable <StudentViewModel> studentviewmodels)
{
var table = new List <StudentViewModel>();
using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient())
{
client.BaseAddress = new Uri(baseUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
ArrayList paramList = new ArrayList();
paramList.Add(JsonConvert.SerializeObject(request));
foreach (StudentViewModel student in studentviewmodels)
{
paramList.Add(JsonConvert.SerializeObject(student));
}
System.Net.Http.HttpResponseMessage response = await client.PutAsync(baseUrl, new StringContent(new JavaScriptSerializer().Serialize(paramList), Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
var data = response.Content.ReadAsStringAsync();
table = Newtonsoft.Json.JsonConvert.DeserializeObject <List <StudentViewModel> >(data.Result);
}
}
if (studentviewmodels != null && ModelState.IsValid)
{
// it is so ignore for now
}
// this will return new data
return(Json(table.ToDataSourceResult(request, ModelState)));
}
public async Task <JsonDefaultResponse <T> > Put <T>(string endpoint, object content)
{
StringContent stringContent = new StringContent(JsonTransformer.Serialize(content), Encoding.UTF8, ContentType);
HttpResponseMessage request = await client.PutAsync(endpoint, stringContent);
return(ReadAndReturn <T>(request));
}
public async Task<HttpResponseMessage> GetResponseAsync(RestCommand command, string data = "")
{
try
{
using (var handler = new HttpClientHandler())
{
if (_credentials != null)
handler.Credentials = _credentials;
using (var httpClient = new HttpClient(handler))
{
ConfigureHttpClient(httpClient);
switch (command.HttpMethod)
{
case HttpMethod.Get:
return await httpClient.GetAsync(command.FullResourceUri);
case HttpMethod.Put:
return await httpClient.PutAsync(command.FullResourceUri, new StringContent(data));
case HttpMethod.Post:
return await httpClient.PostAsync(command.FullResourceUri, new StringContent(data));
case HttpMethod.Delete:
return await httpClient.DeleteAsync(command.FullResourceUri);
}
throw new Exception(string.Format("The command '{0}' does not have a valid HttpMethod. (Type: {1})", command, command.GetType().FullName));
}
}
}
catch (Exception e)
{
throw new Exception("An error occured while performing the request.", e);
}
}
public async Task <T> PutClient <T>(string resource, string jsonRequest = "")
{
T result = default(T);
await Task.Run(async() =>
{
var client = new System.Net.Http.HttpClient(new NativeMessageHandler());
client.BaseAddress = baseUrl;
if (!string.IsNullOrWhiteSpace(App.Token))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", App.Token);
}
var content = new StringContent(jsonRequest, Encoding.UTF8, "text/json");
var response = await client.PutAsync(resource, content);
var responseJson = response.Content.ReadAsStringAsync().Result;
result = JsonConvert.DeserializeObject <T>(responseJson);
client.Dispose();
if (result == null)
{
throw new Exception();
}
});
return(result);
}
public void FakeServer_CapturesAllRequests()
{
using (var fakeServer = new FakeServer())
{
fakeServer.Start();
var baseAddress = fakeServer.BaseUri;
Action<Action, int> repeat = (a, times) =>
{
for (var i = 0; i < times; i++)
a();
};
var url1 = "/request1";
var url2 = "/request2";
var url3 = "/request3";
var url4 = "/request4";
var httpClient = new HttpClient();
httpClient.DeleteAsync(new Uri(baseAddress + url1)).Wait();
repeat(() => httpClient.GetAsync(new Uri(baseAddress + url2)).Wait(), 2);
repeat(() => httpClient.PostAsync(new Uri(baseAddress + url3), new StringContent(url3)).Wait(), 3);
repeat(() => httpClient.PutAsync(new Uri(baseAddress + url4), new StringContent(url4)).Wait(), 4);
fakeServer.CapturedRequests.Count(x => x.Method == Http.Delete && x.Url == url1).Should().Be(1);
fakeServer.CapturedRequests.Count(x => x.Method == Http.Get && x.Url == url2).Should().Be(2);
fakeServer.CapturedRequests.Count(x => x.Method == Http.Post && x.Url == url3 && x.Body == url3).Should().Be(3);
fakeServer.CapturedRequests.Count(x => x.Method == Http.Put && x.Url == url4 && x.Body == url4).Should().Be(4);
}
}
private void List_ItemClick(object sender, ItemClickEventArgs args)
{
JoinGameViewModel gameView = args.ClickedItem as JoinGameViewModel;
var localSettings = ApplicationData.Current.LocalSettings;
string userId = localSettings.Values[App.USER_ID].ToString();
HttpResponseMessage response = new HttpResponseMessage();
var jsonString = JsonConvert.SerializeObject(new
{
GameId = gameView.Id,
UserId = userId
});
var content = new StringContent(jsonString, Encoding.UTF8, "application/json");
var str = "";
using (var client = new HttpClient())
{
Task task = Task.Run(async () =>
{
response = await client.PutAsync(App.BaseUri + "games/JoinGame", content);
str = await response.Content.ReadAsStringAsync();
});
task.Wait();
}
Debug.WriteLine("ID: " + str);
App.RootFrame.Navigate(typeof(Play), gameView.Id);
}
public async Task<Result> PutData(Uri uri, StringContent json, UserAuthenticationEntity userAuthenticationEntity, string language = "ja")
{
using (var httpClient = new HttpClient())
{
try
{
var authenticationManager = new AuthenticationManager();
Result result = new Result(false, "");
if (RefreshTime(userAuthenticationEntity.ExpiresInDate))
{
var tokens = await authenticationManager.RefreshAccessToken(userAuthenticationEntity.RefreshToken);
result.Tokens = tokens.Tokens;
}
httpClient.DefaultRequestHeaders.Add("Accept-Language", language);
httpClient.DefaultRequestHeaders.Add("Origin", "http://psapp.dl.playstation.net");
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", userAuthenticationEntity.AccessToken);
var response = await httpClient.PutAsync(uri, json);
var responseContent = await response.Content.ReadAsStringAsync();
result.IsSuccess = response.IsSuccessStatusCode;
result.ResultJson = responseContent;
return result;
}
catch (Exception)
{
return new Result(false, string.Empty);
}
}
}
public async Task SaveShopListAsync(ShopList item, bool isNewItem = true)
{
Uri uri = new Uri(string.Format(RestUrl, string.Empty));
try
{
string json = JsonConvert.SerializeObject(item);
StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
HttpResponseMessage response = null;
if (isNewItem)
{
response = await client.PostAsync(uri, content);
}
else
{
response = await client.PutAsync(uri, content);
}
if (response.IsSuccessStatusCode)
{
Console.WriteLine(@"\tTodoItem successfully saved.");
}
}
catch (Exception ex)
{
Console.WriteLine(@"\tERROR {0}", ex.Message);
}
}
public static async Task<string> UploadImageToBlobStorage(StorageFile image, string targetUrl)
{
//Upload image with HttpClient to the blob service using the generated item.SAS
// TODO - add BusyDisposer
using (new BusyDisposer())
using (var client = new HttpClient())
{
//Get a stream of the media just captured
using (var fileStream = await image.OpenStreamForReadAsync())
{
var content = new StreamContent(fileStream);
content.Headers.Add("Content-Type", image.ContentType);
content.Headers.Add("x-ms-blob-type", "BlockBlob");
using (var uploadResponse = await client.PutAsync(new Uri(targetUrl), content))
{
if (uploadResponse.StatusCode != HttpStatusCode.Created)
{
throw new Exception(string.Format("Upload Failed {0}", uploadResponse.ToString()));
}
// remove the SAS querystring from the insert result
return targetUrl.Substring(0, targetUrl.IndexOf('?'));
}
}
}
}
/// <summary>
/// Device登録.
/// </summary>
/// <returns></returns>
private async Task registerAsync()
{
var httpClient = new System.Net.Http.HttpClient();
httpClient.DefaultRequestHeaders.Accept.Clear();
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", createSignature());
var stringPayload = Newtonsoft.Json.JsonConvert.SerializeObject(new
{
deviceId = guid.ToString()
});
var httpContent = new System.Net.Http.StringContent(stringPayload, System.Text.Encoding.UTF8, "application/json");
var res = await httpClient.PutAsync($"https://{hostname}/devices/{guid.ToString()}?api-version=2016-11-14", httpContent);
if (HttpStatusCode.OK.Equals(res?.StatusCode))
{
var str = await res.Content.ReadAsStringAsync();
var ret = Newtonsoft.Json.JsonConvert.DeserializeObject <responseRegister>(str);
deviceId = ret.deviceId;
}
}
private async void LeaveAnEvent()
{
try
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", this.parent.Bearer));
var raw = new List<KeyValuePair<string, string>>
{
};
var content = new FormUrlEncodedContent(raw);
string link = this.URI_JOIN_LEAVE.ToString() + "leave/" + this.numericId.Value;
using (var response = await client.PutAsync(link, content))
{
if (response.IsSuccessStatusCode)
{
MessageBox.Show("The event was left.");
}
else
{
MessageBox.Show(response.ReasonPhrase, "Error");
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
}
}
public async Task OpenNotificationsChannel()
{
UpdateStatusMessage("1. Requesting Channel from WNS: ");
try
{
//1. Request Channel from WNS
_channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
UpdateStatusMessage(string.Format(" Channel URI returned by WNS: {0}", _channel.Uri));
UpdateStatusMessage(string.Format("2. Attempting to registering channel URI with Notification App Server at {0}", K_SERVERURL));
//2. Register _channel with your app server
using (var client = new HttpClient())
{
var payload = CreatePayload(_appId, _channel, _tileId, _clientId, _userId, _deviceType);
var result = await client.PutAsync(K_SERVERURL, payload);
if (result.StatusCode == System.Net.HttpStatusCode.Accepted)
UpdateStatusMessage(string.Format(" Channel URI successfully sent to Notification App Server."));
else
UpdateStatusMessage(string.Format(" Could not send Channel URI to Notification App Server - {0}", result.StatusCode.ToString()));
}
}
catch (Exception ex)
{
UpdateStatusMessage(string.Format(" Error occured please see exception detail: {0}", ex.ToString()));
}
}
//The CreateIndex function creates the Search Service and its indexes.
//Also loads the schema.
static bool CreateIndex()
{
// Add some data to the newly created index
Uri requestUri = new Uri(serviceUrl + indexName + "?" + ApiVersion);
// Load the json containing the schema from an external file
//string json = System.IO.File.ReadAllText("schema.json");
string json = System.IO.File.ReadAllText(System.Web.HttpContext.Current.Server.MapPath("~/Data/schema.json"));
using (HttpClient client = new HttpClient())
{
// Create the index
client.DefaultRequestHeaders.Add("api-key", primaryKey);
HttpResponseMessage response = client.PutAsync(requestUri, // To create index use PUT
new StringContent(json, Encoding.UTF8, "application/json")).Result;
if (response.StatusCode == HttpStatusCode.NoContent) // For Posts we want to know response had no content
{
//Console.WriteLine("Index created. \n");
return true;
}
// Console.WriteLine("Index creation failed: {0} {1} \n", (int)response.StatusCode, response.Content.ReadAsStringAsync().Result.ToString());
return false;
}
}
public ElasticsearchResponse DoSyncRequest(string method, Uri uri, byte[] data = null)
{
var client = new System.Net.Http.HttpClient();
HttpResponseMessage response = null;
byte[] result = null;
HttpContent content = null;
if (data != null)
content = new ByteArrayContent(data);
switch (method.ToLower())
{
case "head":
response = client.SendAsync(new HttpRequestMessage(HttpMethod.Head, uri) ).Result;
result = response.Content.ReadAsByteArrayAsync().Result;
break;
case "delete":
response = client.SendAsync(new HttpRequestMessage(HttpMethod.Delete, uri) { Content = content }).Result;
result = response.Content.ReadAsByteArrayAsync().Result;
break;
case "put":
response = client.PutAsync(uri, content).Result;
result = response.Content.ReadAsByteArrayAsync().Result;
break;
case "post":
response = client.PostAsync(uri, content).Result;
result = response.Content.ReadAsByteArrayAsync().Result;
break;
case "get":
response = client.GetAsync(uri).Result;
result = response.Content.ReadAsByteArrayAsync().Result;
break;
}
return ElasticsearchResponse.Create(this._settings, (int)response.StatusCode, method, uri.ToString(), data, result);
}
public void inline_call_to_invalidate_using_expression_tree_is_correct()
{
var client = new HttpClient(_server);
var result = client.PutAsync(_url + "Put", new StringContent(string.Empty)).Result;
_cache.Verify(s => s.RemoveStartsWith(It.Is<string>(x => x == "inlineinvalidate-get_c100_s100")), Times.Exactly(1));
}
/// <summary>
/// Http Put方式更新数据
/// </summary>
/// <param name="url"></param>
/// <param name="content"></param>
/// <returns></returns>
public ResponseResult <T> HttpPut <T>(string url, object content, WebHeaderCollection webHeaders = null,
ResponseResultType resultType = ResponseResultType.ResultInfo)
{
try
{
//设置全局定义的个性化安全认证
SetDefaultHeaders(_httpItem.SecurityHeaders);
//加载或者更新私定的安全认证
SetDefaultHeaders(webHeaders);
var postData = JsonConvert.SerializeObject(content);
var httpContent = new StringContent(postData, Encoding.UTF8);
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json")
{
CharSet = "utf-8"
};
var postResult = _client.PutAsync(url, httpContent);
//处理数据解析
return(JsonConvertResultData <T>(postResult, resultType));
}
catch (InvalidOperationException ex)
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = ex.StackTrace
});
}
catch (Exception ex)
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = ex.StackTrace
});
}
}
public static async void ResetStateForms()
{
using (var client = new HttpClient() { BaseAddress = new Uri(PrintToolWebAPI) })
{
await client.PutAsync("api/Print", null);
}
}
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);
}
}
}
static void Main(string[] args)
{
Uri baseAddress = new Uri("http://*****:*****@gmail.com", PhoneNo = "789" };
Console.WriteLine("\n添加联系人003");
httpClient.PutAsync<Contact>("/api/contacts", contact, new JsonMediaTypeFormatter()).Wait();
contacts = httpClient.GetAsync("/api/contacts").Result.Content.ReadAsAsync<IEnumerable<Contact>>().Result;
ListContacts(contacts);
contact = new Contact { Id = "003", Name = "王五", EmailAddress = "*****@*****.**", PhoneNo = "987" };
Console.WriteLine("\n修改联系人003");
httpClient.PostAsync<Contact>("/api/contacts", contact, new XmlMediaTypeFormatter()).Wait();
contacts = httpClient.GetAsync("/api/contacts").Result.Content.ReadAsAsync<IEnumerable<Contact>>().Result;
ListContacts(contacts);
Console.WriteLine("\n删除联系人003");
httpClient.DeleteAsync("/api/contacts/003").Wait();
contacts = httpClient.GetAsync("/api/contacts").Result.Content.ReadAsAsync<IEnumerable<Contact>>().Result;
ListContacts(contacts);
Console.Read();
}
public LoginRetorno Autenticar(Login login)
{
LoginRetorno json = new LoginRetorno();
try
{
string URL = "https://f12xi0nh5j.execute-api.us-east-1.amazonaws.com/dev/login";
string DATA = "{\"login\": \"" + login.email + "\" , \"senha\" : \"" + login.senha + "\"}";
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
client.BaseAddress = new System.Uri(URL);
byte[] cred = UTF8Encoding.UTF8.GetBytes("username:password");
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(cred));
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
System.Net.Http.HttpContent content = new StringContent(DATA, UTF8Encoding.UTF8, "application/json");
HttpResponseMessage messge = client.PutAsync(URL, content).Result;
string description = string.Empty;
if (messge.IsSuccessStatusCode)
{
string result = messge.Content.ReadAsStringAsync().Result;
json = JsonConvert.DeserializeObject <LoginRetorno>(result, new JsonSerializerSettings
{
DateFormatString = "yyyy-MM-dd"
});
}
}
catch (Exception ex)
{
throw new Exception("Problemas ao realizar login. Contacte do administrador!");
}
return(json);
}
public static async Task <HttpResponseMessage> PutAsync(this System.Net.Http.HttpClient client, object data)
{
var putData = Newtonsoft.Json.JsonConvert.SerializeObject(data);
using (HttpContent httpContent = new StringContent(putData, Encoding.UTF8))
{
var clientDefaultHeaders = client.DefaultRequestHeaders
.FirstOrDefault(o => o.Key.ToLower().Equals("content-type"))
.Value.FirstOrDefault() ?? "";
if (!string.IsNullOrEmpty(clientDefaultHeaders))
{
httpContent.Headers.ContentType =
new System.Net.Http.Headers.MediaTypeHeaderValue(clientDefaultHeaders);
;
}
else
{
httpContent.Headers.ContentType =
new System.Net.Http.Headers.MediaTypeHeaderValue(HttpClientContext.DefaultContentType);
;
}
SetHiSecuritySignHeader(client, httpContent, data, "put");
var response = await client.PutAsync(client.BaseAddress, httpContent);
WriteClientLog(client.BaseAddress.AbsoluteUri, "Put:" + client.BaseAddress.AbsoluteUri,
httpContent.GetSerializeObject(), response.Content.ReadAsStringAsync().Result);
client.Dispose();
return(response);
}
}
public async Task <T> Put <T>(string url, T content)
{
try
{
var serializedContent = JsonConvert.SerializeObject(content);
var contentBuffer = Encoding.UTF8.GetBytes(serializedContent);
var contentByteArray = new ByteArrayContent(contentBuffer);
contentByteArray.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
var response = await Client.PutAsync(url, contentByteArray);
if ((int)response.StatusCode >= 200 && (int)response.StatusCode <= 299)
{
var serializedData = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <T>(serializedData));
}
else if ((int)response.StatusCode == 400)
{
throw new BadRequestException(response.ReasonPhrase);
}
else if ((int)response.StatusCode == 404)
{
throw new BadRequestException(response.ReasonPhrase);
}
else
{
throw new Exception(response.ReasonPhrase);
}
}
catch (HttpRequestException e)
{
throw e;
}
}
private HttpResponseMessage PutSync(StringContent objectContent)
{
string result = string.Empty;
try
{
var httpResponseMessage = _httpClient.PutAsync(_addressSuffix, objectContent).Result;
if (httpResponseMessage.StatusCode == HttpStatusCode.NotFound)
{
throw new ExcecaoAcessoApi();
}
if (httpResponseMessage.StatusCode == HttpStatusCode.OK)
{
return(httpResponseMessage);
}
result = httpResponseMessage.Content.ReadAsStringAsync().Result;
var jsonErrorDataResponse = JsonConvert.DeserializeObject <JsonErrorDataResponse>(result);
throw new ExcecaoRestful(jsonErrorDataResponse, httpResponseMessage.StatusCode);
}
catch (ExcecaoRestful)
{
throw;
}
catch (Exception)
{
throw new Exception(result);
}
}
// https://forums.asp.net/t/1773007.aspx?How+to+correctly+use+PostAsync+and+PutAsync+
public string Put <T>(T data)
{
System.Net.Http.Headers.MediaTypeHeaderValue mediaType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
Newtonsoft.Json.JsonSerializerSettings jsonSerializerSettings =
new Newtonsoft.Json.JsonSerializerSettings();
// JsonNetFormatter jsonFormatter = new JsonNetFormatter(jsonSerializerSettings);
// var requestMessage = new
// System.Net.Http.HttpRequestMessage<T>(data, mediaType
// , new System.Net.Http.Formatting.MediaTypeFormatter[] { jsonFormatter });
System.Net.Http.ObjectContent content = new System.Net.Http.ObjectContent <T>(data
, new System.Net.Http.Formatting.JsonMediaTypeFormatter()
);
using (System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient())
{
string _endpoint = "";
httpClient.PutAsync(_endpoint, content).ContinueWith(httpResponseMessage =>
{
return(httpResponseMessage.Result.Content.ReadAsStringAsync());
// return await Task.Run(() => httpResponseMessage.Result.Content.ReadAsStringAsync());
});
}
return(null);
}
public static async Task UpdateProperty(this User user, string property, JToken value)
{
var o = @"{""user"":{""[:p]"":""[:v]""}}"
.Replace("[:p]", property)
.Replace("[:v]", value.ToString());
var client = new HttpClient
{
DefaultRequestHeaders =
{
{"Accept", "application/json"},
{"X-Auth-Token", App.Connection.SessionController.CurrentSession.AuthToken}
}
};
var response =
await
client.PutAsync(Endpoints.User.Replace("[:id]", App.Connection.SessionController.CurrentSession.Id),
new JsonContent(o));
var responseObject =
JsonConvert.DeserializeObjectAsync<WebResponse<User>>(await response.Content.ReadAsStringAsync());
if (responseObject.Result.Flash != null)
{
App.Connection.NotificationController.Notification.Notify(responseObject.Result.Flash.Message);
return;
}
responseObject.Result.Result.CopyTo(App.Connection.SessionController.CurrentSession);
responseObject.Result.Result.CopyTo(App.Connection.ModelController.Users[App.Connection.SessionController.CurrentSession.Id]);
Main.Instance.InitSession();
}
public async System.Threading.Tasks.Task <string> Put <T>(string uri, T data)
{
using (System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient())
{
System.Net.Http.Headers.MediaTypeHeaderValue mediaType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
Newtonsoft.Json.JsonSerializerSettings jsonSerializerSettings =
new Newtonsoft.Json.JsonSerializerSettings();
JsonNetFormatter jsonFormatter = new JsonNetFormatter(jsonSerializerSettings);
System.Net.Http.ObjectContent content = new System.Net.Http.ObjectContent <T>(data
, new System.Net.Http.Formatting.JsonMediaTypeFormatter()
);
System.Net.Http.HttpResponseMessage response = await httpClient.PutAsync(uri, content);
response.EnsureSuccessStatusCode();
return(response.Content.ReadAsStringAsync().Result);
/*
* var requestMessage = new System.Net.Http.HttpRequestMessage
* (data, mediaType, new System.Net.Http.Formatting.MediaTypeFormatter[] { jsonFormatter });
*
* // var result = httpClient.PutAsync("_endpoint", requestMessage.Content).Result;
* // return result.Content.ReadAsStringAsync().Result;
*/
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
Game game = (Game) e.Parameter;
TimeSpan timeSpan = (game.FinishedAt - game.StartedAt);
string timespanString = timeSpan.Days + "d " + timeSpan.Hours + "h " + timeSpan.Minutes + "m " + timeSpan.Seconds + "s";
timeTextBlock.Text += " " + timespanString;
string[] difficulties = { "Normal", "Hard", "Insane" };
difficultyTextBlock.Text += " " + difficulties[game.Difficulty];
using (var client = new HttpClient())
{
var content = JsonConvert.SerializeObject(game);
// Send a POST
Task task = Task.Run(async () =>
{
var request = new StringContent(content, Encoding.UTF8, "application/json");
await client.PutAsync(App.BaseUri + "games", request);
});
task.Wait();
}
// Back button
SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility = AppViewBackButtonVisibility.Visible;
SystemNavigationManager.GetForCurrentView().BackRequested += OnBackRequested;
}
async private static void OnTimedEvent(Object source, ElapsedEventArgs e)
{
switch (effectMode) {
case "test":
TestPut();
break;
case "ambient":
AmbientPut();
break;
case "daylight":
DaylightPut();
break;
}
try {
HttpClient client = new HttpClient();
StringContent content = new StringContent(JsonParser.Serialize(bufferData), Encoding.UTF8);
if (effectsOn) {
await client.PutAsync(lightArray[lastLight], content);
}
} catch (Exception) { return; } finally {
lastLight++;
if (lastLight >= lightArray.Length) {
lastLight = 0;
}
}
}
protected void ButtonAddFriend_Click(object sender, EventArgs e)
{
LinkButton button = sender as LinkButton;
if (button.Text == "Add frined")
{
var httpClient = new HttpClient();
var userAccessToken = Session["AccessToken"];
var userWallId = Request.QueryString["uid"];
var bearer = "Bearer " + userAccessToken;
httpClient.DefaultRequestHeaders.Add("Authorization", bearer);
var postQuery = String.Format(EndPoints.AddFriend, userWallId);
var response = httpClient.PutAsync(postQuery, null).Result;
}
else
{
var httpClient = new HttpClient();
var userAccessToken = Session["AccessToken"];
var userWallId = Request.QueryString["uid"];
var bearer = "Bearer " + userAccessToken;
httpClient.DefaultRequestHeaders.Add("Authorization", bearer);
var postQuery = String.Format(EndPoints.RemoveFriend, userWallId);
var response = httpClient.PutAsync(postQuery, null).Result;
}
Response.Redirect(Request.RawUrl);
}
public static async Task <HttpResponseMessage> PutAsJsonAsync(this System.Net.Http.HttpClient client, string requestUrl, object model)
{
var json = JsonConvert.SerializeObject(model);
var stringContent = new StringContent(json, Encoding.UTF8, JsonMediaType);
var response = await client.PutAsync(requestUrl, stringContent);
return(response);
}
public static Task <HttpResponseMessage> PutAsJsonAsync <T>(this System.Net.Http.HttpClient httpClient, string resource, T data)
{
var dataAsString = JsonConvert.SerializeObject(data);
var content = new StringContent(dataAsString);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(httpClient.PutAsync(resource, content));
}
/// <summary>
/// PUT-запрос
/// </summary>
/// <param name="client">HttpCLient</param>
/// <param name="requestUri">Адрес назначения</param>
/// <param name="body">Передаваемый объект</param>
/// <typeparam name="T">Тип возвращаемого значения</typeparam>
/// <returns></returns>
public static async Task <T> PutAsync <T>(this System.Net.Http.HttpClient client, string requestUri, object body)
{
var jsonContent = new JsonContent(body);
var response = await client.PutAsync(requestUri, jsonContent);
return(await response.Content.ReadAsAsync <T>());
}
public static async Task <T> PutAsync <T>(this System.Net.Http.HttpClient httpClient, string url, object data)
{
var responseMessage = await httpClient.PutAsync(url, data);
responseMessage.EnsureSuccessStatusCode();
var result = await responseMessage.Content.ReadAsync <T>();
return(result);
}
public async Task <JsonDefaultResponse <T> > Put <T>(string endpoint, object content)
{
StringContent stringContent = new StringContent(JsonTransformer.Serialize(content), Encoding.UTF8, "application/json");
HttpResponseMessage request = await client.PutAsync(endpoint, stringContent);
string response = request.Content.ReadAsStringAsync().Result;
return(JsonTransformer.Deserialize <JsonDefaultResponse <T> >(response));
}
public Task <HttpResponseMessage> DoPut(object jsonBody, string uri)
{
string json = JsonConvert.SerializeObject(jsonBody);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = _client.PutAsync(uri, content);
return(response);
}
private async Task <bool> PutSupplierAsync(Suppliers supplier)
{
// Post API call to insert passed in Suppliers object into database. Return status code for verification
HttpClient client = new System.Net.Http.HttpClient();
var content = JsonConvert.SerializeObject(supplier);
var httpContent = new StringContent(content, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PutAsync($"https://localhost:44327/api/SuppliersAPI/{supplier.SupplierId}", httpContent);
return(true);
}
private async Task <HttpStatusCode> PutProductAsync(string path, Products product)
{
// Update Product Objects in PUT Request, path includes ProductsID
HttpClient client = new System.Net.Http.HttpClient();
var content = JsonConvert.SerializeObject(product);
var httpContent = new StringContent(content, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PutAsync(path + "/" + product.ProductId, httpContent);
return(response.StatusCode);
}
public async Task <TEntity> PutAsync <TEntity>(string url, HttpContent content, CancellationToken?token = null) where TEntity : class, new()
{
//var log = Logger.Debug(Tag, $"Put() {url}...");
//if (CurrentUser != null)
// Client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", CurrentUser.Token);
var response = await Client.PutAsync(url, content, token ?? CancellationToken.None).ConfigureAwait(false);
response = Validate(response);
return(await ContentToEntity <TEntity>(response).ConfigureAwait(false));
}
public async Task <IHttpResponseMessage> PutAsync(Uri requestUri, IHttpContent content, CancellationToken cancellationToken)
{
Http.HttpContent httpContent = null;
if (content != null)
{
httpContent = ((HttpContent)content).Content;
}
var response = await client.PutAsync(requestUri, httpContent, cancellationToken);
return(new HttpResponseMessage(response));
}
public async Task <TResponse> PutAsync <TRequest, TResponse>(string resourceUrl, TRequest request, Dictionary <string, string> headers = null)
{
AddHeadersToRequest(headers);
var content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, MediaTypeNames.Application.Json);
var result = await _httpClient.PutAsync(resourceUrl, content);
var jsonResponse = await result.Content.ReadAsStringAsync();
var response = JsonConvert.DeserializeObject <TResponse>(jsonResponse);
return(response);
}
public Task <HttpResponseMessage> PutAsync(string url, object putContent, CancellationToken cancellationToken)
{
var body = new StringContent(JsonConvert.SerializeObject(putContent), Encoding.UTF8, this.ContentJsonPoint);
using (var client = new System.Net.Http.HttpClient())
{
client.BaseAddress = new Uri(this.BaseUrlEndPoint);
client.DefaultRequestHeaders.Add("accept", this.ContentJsonPoint);
return(client.PutAsync(url, body, cancellationToken));
}
}
public static async Task <ResponseResult <TResult> > PutAsync <TResult>(this System.Net.Http.HttpClient client, string url, HttpContent data)
{
using var response = await client.PutAsync(url, data);
return(new ResponseResult <TResult>
{
Succeed = response.IsSuccessStatusCode,
StatusCode = response.StatusCode,
Headers = response.Headers,
Result = await response.Content.ReadAsync <TResult>()
});
}
private string HttpRequest(string url, HttpContent content, RequestMethod requestMethod)
{
string responseStr = null;
for (int i = 0; i < RetryCount; i++)
{
try
{
HttpResponseMessage response;
switch (requestMethod)
{
case RequestMethod.Post:
response = _httpClient.PostAsync(url, content).Result;
break;
case RequestMethod.Put:
response = _httpClient.PutAsync(url, content).Result;
break;
case RequestMethod.Get:
case RequestMethod.Delete:
throw new NotSupportedException();
default:
throw new ArgumentOutOfRangeException(nameof(requestMethod), requestMethod, null);
}
// ensure if the request is success.
response.EnsureSuccessStatusCode();
// read the Json asynchronously.
// notice currently was auto decompressed with GZip,
// because AutomaticDecompression was set to DecompressionMethods.GZip
responseStr = response.Content.ReadAsStringAsync().Result;
return(responseStr);
}
catch (Exception)
{
Debug.WriteLine(string.Format("Tried {0} time{1} for timed out. (>{2}ms): {3}",
i + 1,
i + 1 > 1 ? "s" : "",
Timeout,
url)
);
if (i == RetryCount - 1)
{
throw;
}
}
}
return(responseStr);
}
public async Task <HttpResponse> PutAsync(string requestURI, HttpContent content, Dictionary <string, string> headers)
{
headers.ToList().ForEach(header =>
{
_client.DefaultRequestHeaders.Remove(header.Key);
_client.DefaultRequestHeaders.Add(header.Key, header.Value);
});
var task = await _client.PutAsync(requestURI, content);
return(new HttpResponse((int)task.StatusCode,
content,
task.ReasonPhrase));
}
private static async Task SongsControllerTest(HttpClient client)
{
// create songs
await client.PostAsync("Songs/Create",
new FormUrlEncodedContent(new[]
{
new KeyValuePair<string, string>("title", "qka pesen 007"),
new KeyValuePair<string, string>("artistid", "2")
}));
await client.PostAsync("Songs/Create",
new FormUrlEncodedContent(new[]
{
new KeyValuePair<string, string>("title", "qka pesen 008"),
new KeyValuePair<string, string>("artistid", "2")
}));
// get all songs
Console.WriteLine(await client.GetStringAsync("Songs/All"));
// update song
await client.PutAsync("Songs/Update",
new FormUrlEncodedContent(new[]
{
new KeyValuePair<string, string>("id", "2"),
new KeyValuePair<string, string>("year", "2010"),
new KeyValuePair<string, string>("genre", "narodna pesen")
}));
// delete song
await client.DeleteAsync("api/Songs/Delete/1");
}
static void Main(string[] args)
{
System.Threading.Thread.Sleep(100);
Console.Clear();
Console.WriteLine("**************************开始执行获取API***********************************");
HttpClient client = new HttpClient();
//Get All Product 获取所有
HttpResponseMessage responseGetAll = client.GetAsync(url + "api/Products").Result;
string GetAllProducts = responseGetAll.Content.ReadAsStringAsync().Result;
Console.WriteLine("GetAllProducts方法：" + GetAllProducts);
//Get Product根据ID获取
HttpResponseMessage responseGetID = client.GetAsync(url + "api/Products/1").Result;
string GetProduct = responseGetID.Content.ReadAsStringAsync().Result;
Console.WriteLine("GetProduct方法：" + GetProduct);
//Delete Product 根据ID删除
HttpResponseMessage responseDeleteID = client.DeleteAsync(url + "api/Products/1").Result;
// string DeleteProduct = responseDeleteID.Content.ReadAsStringAsync().Result;
Console.WriteLine("DeleteProduct方法：" );
//HttpContent abstract 类
//Post Product 添加Product对象
var model = new Product { Id = 3, Name = "Hammer", Category = "Hardware", Price = 16.99M };
HttpContent content = new ObjectContent(typeof(Product), model, new JsonMediaTypeFormatter());
client.PostAsync(url + "api/Products/", content);
//Put Product 修改Product
client.PutAsync(url + "api/Products/", content);
Console.ReadKey();
}