static async Task Main(string[] args) { Console.WriteLine("Calling the back-end API"); var url = "http://localhost:5000/" + "api/values"; var customDelegatingHandler = new CustomDelegatingHandler(); var client = HttpClientFactory.Create(customDelegatingHandler); HttpResponseMessage getResponse = await client.GetAsync(url); if (getResponse.IsSuccessStatusCode) { string responseString = await getResponse.Content.ReadAsStringAsync(); Console.WriteLine(responseString); Console.WriteLine("GET - HTTP Status: {0}, Reason {1}", getResponse.StatusCode, getResponse.ReasonPhrase); } else { Console.WriteLine("Failed to call the API. HTTP Status: {0}, Reason {1}", getResponse.StatusCode, getResponse.ReasonPhrase); } //var order = new Order { OrderID = 10248, CustomerName = "Taiseer Joudeh", ShipperCity = "Amman", IsShipped = true }; var order = new Foo("webhook"); string json = JsonConvert.SerializeObject(order); var content = new StringContent(json, Encoding.UTF8, "application/json"); HttpResponseMessage postResponse = await client.PostAsync(url, content); if (postResponse.IsSuccessStatusCode) { string responseString = await postResponse.Content.ReadAsStringAsync(); Console.WriteLine("POST - HTTP Status: {0}, Reason {1}. Press ENTER to exit", postResponse.StatusCode, postResponse.ReasonPhrase); } else { Console.WriteLine("Failed to call the API. HTTP Status: {0}, Reason {1}", postResponse.StatusCode, postResponse.ReasonPhrase); } Console.ReadLine(); }
/** * GETs data from the provided-path relative to the base-url. * * @param path -- if null/empty, refers to the base-url * @return {@link FirebaseResponse} * @throws UnsupportedEncodingException * @throws {@link FirebaseException} */ public FirebaseResponse Get(string path) { // make the request HttpClient client = HttpClientFactory.Create() client.BaseAddress = new Uri(url); HttpClient request = new HttpGet(url); HttpClient HttpResponseMessage httpResponse = this.makeRequest(request); // process the response FirebaseResponse response = this.ProcessResponse(FirebaseRestMethod.GET, httpResponse); return(response); }
// Request data from telemetry server handle possible exceptions static async Task GetData() { var httpClient = HttpClientFactory.Create(); var url = "http://localhost:25555/api/ets2/telemetry"; try { data = await httpClient.GetStringAsync(url); } catch (Exception e) { Debug.WriteLine(e.Message); ((MainWindow)Application.Current.MainWindow).textBlock.Text = "Telemetry server is not running!\nPlease run it before hitting the 'Start' button."; ((MainWindow)Application.Current.MainWindow).processIndicator.Fill = new SolidColorBrush(Colors.Red); ((MainWindow)Application.Current.MainWindow).textBlockTwo.Text = "Error! Telemetry server not running"; Thread.Sleep(5000); Environment.Exit(Environment.ExitCode); } }
public async Task <IActionResult> Register(RestReportsModel restReportsModel) { var client = HttpClientFactory.Create(); var result = await client.PostAsJsonAsync( new Uri(connectionString + "api/Rest/Post"), restReportsModel); if (result.IsSuccessStatusCode == false) { return(BadRequest()); } var loadContent = await result.Content.ReadAsStringAsync(); var getAllContent = JsonConvert .DeserializeObject <RestReportsModel>(loadContent); return(Ok(getAllContent)); }
private async Task <bool> DownloadSchemaAsync( UpdateCommandContext context, Uri serviceUri, string schemaFilePath, CancellationToken cancellationToken) { using IActivity activity = Output.WriteActivity("Download schema"); HttpClient client = HttpClientFactory.Create( context.Uri ?? serviceUri, context.Token, context.Scheme, context.CustomHeaders); return(await IntrospectionHelper.DownloadSchemaAsync( client, FileSystem, activity, schemaFilePath, cancellationToken) .ConfigureAwait(false)); }
private static async Task <string> UploadData(string uri, HttpContent formData, CancellationToken token, Dictionary <string, string> extraHeaders = null) { ProgressMessageHandler progress = new ProgressMessageHandler(); progress.HttpSendProgress += HttpSendProgress; HttpRequestMessage message = new HttpRequestMessage(); message.Method = HttpMethod.Post; message.Content = formData; message.RequestUri = new Uri(uri); using (var client = HttpClientFactory.Create(progress)) { client.DefaultRequestHeaders.Add("User-Agent", "LXtory/1.0"); client.DefaultRequestHeaders.Add("Connection", "Close"); client.Timeout = Timeout.InfiniteTimeSpan; if (extraHeaders != null) { foreach (KeyValuePair <string, string> header in extraHeaders) { client.DefaultRequestHeaders.Add(header.Key, header.Value); } } var response = await client.SendAsync(message, token); if (response.IsSuccessStatusCode) { return(await response.Content.ReadAsStringAsync()); } else { var error = await response.Content.ReadAsStringAsync(); if (error.Length > 512) { error = ""; } throw new Exception($"Upload error.\r\n{response.ReasonPhrase}\r\n{error}"); } } }
/// <summary> /// /// </summary> /// <param name="appId"></param> /// <param name="appKey"></param> /// <param name="isDevelopment"></param> public CoinyProClient(string appId, string appKey, bool isDevelopment = true) { if (string.IsNullOrEmpty(appId)) { throw new ArgumentNullException(nameof(appId)); } if (string.IsNullOrEmpty(appKey)) { throw new ArgumentNullException(nameof(appKey)); } var client = HttpClientFactory.Create(new ClientHandler(appId, appKey)); client.BaseAddress = isDevelopment ? new Uri("https://api-coiny-pro-dev.azurewebsites.net/") : new Uri("https://api-pro.coiny.io/"); WalletService = new WalletService(client); OrderService = new OrderService(client); TradePairService = new TradePairService(client); }
public ZohoApiService() { _apiTokenUrl = ConfigurationManager.AppSettings["zoho:ApiTokenUrl"]; _apiUploadUrl = ConfigurationManager.AppSettings["zoho:ApiUploadUrl"]; if (string.IsNullOrEmpty(_apiTokenUrl)) { throw new ConfigurationErrorsException("Please add 'zohoApiTokenUrl' settigns to .config file."); } if (string.IsNullOrEmpty(_apiUploadUrl)) { throw new ConfigurationErrorsException("Please add 'zohoApiUploadUrl' settigns to .config file."); } _httpClient = HttpClientFactory.Create(); _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("multipart/form-data")); _httpClient.DefaultRequestHeaders.Add("Authorization", $"Zoho-oauthtoken {AccessToken}"); }
/// <summary> /// POST 请求 地址 /// </summary> /// <param name="url">请求 地址</param> /// <param name="postJson">post 的 json 字符串</param> /// <returns></returns> public static async Task <string> HttpPostAsync(string url, string postJson) { string html = string.Empty; using (var httpClient = HttpClientFactory.Create()) { using (var httpContent = new StringContent(postJson)) { httpContent.Headers.ContentType = new MediaTypeHeaderValue(HttpContentTypeKeys.APPLICATION_JSON); var httpResponseMessage = await httpClient.PostAsync(url, httpContent); //data = await GetResponseContentDataAsync<TReturnDataModel>(httpResponseMessage); html = await GetResponseContentStringAsync(httpResponseMessage); } } return(html); }
public HttpResponseMessage PostCreateTimeSeries(string tokenValue, TestTimeSeriesMetadataModel model) { using (HttpClient client = HttpClientFactory.Create()) { client.DefaultRequestHeaders .Accept .Add(new MediaTypeWithQualityHeaderValue(CommonHttpConstants.ApplicationJsonMedia)); if (tokenValue != null) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(CommonHttpConstants.AuthorizationHeader, tokenValue); } return(client.LogAndPost($"{BaseApiRoute}", new StringContent(model.ToString(), Encoding.UTF8, CommonHttpConstants.ApplicationJsonMedia), Logger)); } }
public async Task Retry_policy_should_work() { var clientWithRetry = HttpClientFactory.Create() .WithPolicy( Policy <HttpResponseMessage> .Handle <HttpRequestException>() .OrResult(result => result.StatusCode >= HttpStatusCode.InternalServerError || result.StatusCode == HttpStatusCode.RequestTimeout) .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(1))) .Build(); var response = await clientWithRetry.GetAsync($"{_server.Urls[0]}{_endpointUri}"); Assert.Equal(2, _server.LogEntries.Count()); Assert.Single(_server.LogEntries, le => (HttpStatusCode)le.ResponseMessage.StatusCode == HttpStatusCode.OK); Assert.Single(_server.LogEntries, le => (HttpStatusCode)le.ResponseMessage.StatusCode == HttpStatusCode.RequestTimeout); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal("Hello world!", await response.Content.ReadAsStringAsync()); }
private static async Task HandleAsync(string serverUrl, string accessToken, string username, string password, string timelineKey, DateTime fromTime, DateTime toTime) { using var client = HttpClientFactory.Create(username, password, accessToken); serverUrl ??= await client.GetCloudServerUrlAsync(); JsonElement home = await client.GetAsJsonAsync(serverUrl, ManicTimeMediaType.V3); JsonElement timelines = await client.GetAsJsonAsync(Urls.Timelines(home.GetLinkHref("manictime/timelines"), timelineKey), ManicTimeMediaType.V3); JsonElement timeline = timelines.GetProperty("timelines").EnumerateArray().SingleOrDefault(); if (timeline.ValueKind == JsonValueKind.Undefined) { throw new InvalidOperationException("Timeline not found."); } JsonElement activities = await client.GetAsJsonAsync(Urls.Activities(timeline.GetLinkHref("manictime/activities"), fromTime, toTime), ManicTimeMediaType.V3); Console.WriteLine(activities.FormatForDisplay()); }
static void Main(string[] args) { string uri = "http://localhost:12345/api/values"; string headerName = "X-Response-Header-To-Protect"; var credential = new Credential() { Id = "dh37fgj492je", Algorithm = SupportedAlgorithms.SHA256, User = "******", Key = "werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn" }; // GET and POST using the Authorization header var handler = new HawkValidationHandler(credentialsCallback: () => credential, verificationCallback: (r, ext) => ext.Equals(headerName + ":" + r.Headers.GetValues(headerName).First())); HttpClient client = HttpClientFactory.Create(handler); var response = client.GetAsync(uri).Result; Console.WriteLine(response.Content.ReadAsStringAsync().Result); response = client.PostAsJsonAsync(uri, credential.User).Result; Console.WriteLine(response.Content.ReadAsStringAsync().Result); // GET using Bewit var hawkClient = new HawkClient(() => credential); string bewit = hawkClient.CreateBewitAsync(new HttpRequestMessage() { RequestUri = new Uri(uri) }, lifeSeconds: 60).Result; // Bewit is handed off to a client needing temporary access to the resource. var clientNeedingTempAccess = new WebClient(); var resource = clientNeedingTempAccess.DownloadString(uri + "?bewit=" + bewit); Console.WriteLine(resource); Console.Read(); }
public async override Task Upload(string filename, Model.UserConfiguration uc, EventHandler <HttpProgressEventArgs> progressHandler, CancellationToken cancelToken) { Dictionary <string, string> values = new Dictionary <string, string>(); values.Add("notes", _appInfo.Notes); values.Add("notes_type", "0"); values.Add("status", _appInfo.Status.ToString()); values.Add("notify", _appInfo.Notify.ToString()); values.Add("release_type", _appInfo.ReleaseType.ToString()); values.Add("mandatory", _appInfo.Mandatory.ToString()); FileStream fs = new FileStream(filename, FileMode.Open); HttpContent formContent = new FormUrlEncodedContent(values); HttpContent fileContent = new StreamContent(fs); MultipartFormDataContent multipartContent = new MultipartFormDataContent(); multipartContent.Add(formContent); multipartContent.Add(fileContent, "ipa", Path.GetFileName(filename)); ProgressMessageHandler progress = new ProgressMessageHandler(); progress.HttpSendProgress += progressHandler; HttpClient client = HttpClientFactory.Create(progress); client.Timeout = TimeSpan.FromMinutes(10); client.DefaultRequestHeaders.Add("X-HockeyAppToken", uc.UserToken); HttpResponseMessage response = null; response = await client.PostAsync(uc.ApiBase + "apps", multipartContent, cancelToken); if (response != null && !response.IsSuccessStatusCode) { throw new Exception(response.ReasonPhrase); } fs.Close(); }
public async Task Test() { if (RpsTest == 0) { return; } var token = await CreateUserAndObtainToken(GenerateUsername()); var step = Step.Create(GetTestName(), HttpClientFactory.Create(), context => { var request = Http.CreateRequest("POST", $"{Url}/web/api/tasks") .WithHeader("accept", "application/json") .WithHeader("authorization", $"Bearer {token}") .WithBody(JsonContent.Create(new object[] { new { title = "create_task_test", uid = Guid.NewGuid(), } })); return(Http.Send(request, context)); }, timeout: TimeSpan.FromSeconds(Timeout)); var scenario = ScenarioBuilder .CreateScenario(GetTestName(), step) .WithWarmUpDuration(TimeSpan.FromSeconds(5)) .WithLoadSimulations( Simulation.KeepConstant(RpsTest, TimeSpan.FromSeconds(TimeTest)) ); var result = await RunScenario(scenario); VerifyResults(result, () => { Assert.NotInRange(result.ScenarioStats[0].StepStats[0].Ok.Request.RPS, 0, 13 * RpsTest); }); }
public async Task FillPipeAsync(DiscordAttachment attachment, PipeWriter writer) { try { using (var fileStream = new FileStream(Path.GetTempFileName(), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, 16384, FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.DeleteOnClose)) { using (var client = HttpClientFactory.Create()) using (var downloadStream = await client.GetStreamAsync(attachment.Url).ConfigureAwait(false)) await downloadStream.CopyToAsync(fileStream, 16384, Config.Cts.Token).ConfigureAwait(false); fileStream.Seek(0, SeekOrigin.Begin); using (var zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Read)) { var logEntry = zipArchive.Entries.FirstOrDefault(e => e.Name.EndsWith(".log", StringComparison.InvariantCultureIgnoreCase)); if (logEntry == null) { throw new InvalidOperationException("No zip entries that match the log criteria"); } using (var zipStream = logEntry.Open()) { int read; FlushResult flushed; do { var memory = writer.GetMemory(Config.MinimumBufferSize); read = await zipStream.ReadAsync(memory, Config.Cts.Token); writer.Advance(read); flushed = await writer.FlushAsync(Config.Cts.Token).ConfigureAwait(false); } while (read > 0 && !(flushed.IsCompleted || flushed.IsCanceled || Config.Cts.IsCancellationRequested)); } } } } catch (Exception e) { Config.Log.Error(e, "Error filling the log pipe"); writer.Complete(e); return; } writer.Complete(); }
public async Task FillPipeAsync(DiscordAttachment attachment, PipeWriter writer) { try { using (var fileStream = new FileStream(Path.GetTempFileName(), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, 16384, FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.DeleteOnClose)) { using (var client = HttpClientFactory.Create()) using (var downloadStream = await client.GetStreamAsync(attachment.Url).ConfigureAwait(false)) await downloadStream.CopyToAsync(fileStream, 16384, Config.Cts.Token).ConfigureAwait(false); fileStream.Seek(0, SeekOrigin.Begin); using (var zipArchive = SevenZipArchive.Open(fileStream)) using (var zipReader = zipArchive.ExtractAllEntries()) while (zipReader.MoveToNextEntry()) { if (!zipReader.Entry.IsDirectory && zipReader.Entry.Key.EndsWith(".log", StringComparison.InvariantCultureIgnoreCase)) { using (var rarStream = zipReader.OpenEntryStream()) { int read; FlushResult flushed; do { var memory = writer.GetMemory(Config.MinimumBufferSize); read = await rarStream.ReadAsync(memory, Config.Cts.Token); writer.Advance(read); flushed = await writer.FlushAsync(Config.Cts.Token).ConfigureAwait(false); } while (read > 0 && !(flushed.IsCompleted || flushed.IsCanceled || Config.Cts.IsCancellationRequested)); } writer.Complete(); return; } } Config.Log.Warn("No 7z entries that match the log criteria"); } } catch (Exception e) { Config.Log.Error(e, "Error filling the log pipe"); } writer.Complete(); }
private async Task <string> FetchPageTitle(string url) { string title = null; var client = HttpClientFactory.Create(); using (var response = await client.GetAsync(new Uri(url, UriKind.Absolute))) { using (var stream = await response.Content.ReadAsStreamAsync()) { // compiled regex to check for <title></title> block var pattern = new Regex(@"<title>\s*(.+?)\s*</title>", RegexOptions.Compiled | RegexOptions.IgnoreCase); var chunkSize = 512; var buffer = new byte[chunkSize]; var contents = ""; var length = 0; while ((title == null) && (length = stream.Read(buffer, 0, chunkSize)) > 0) { // convert the byte-array to a string and add it to the rest of the // contents that have been downloaded so far contents += Encoding.UTF8.GetString(buffer, 0, length); var match = pattern.Match(contents); if (match.Success) { // we found a <title></title> match title = match.Groups[1].Value; } else if (contents.Contains("</head>")) { // reached end of head-block; no title found title = string.Empty; } } } } return(title); }
/// <summary> /// /// </summary> /// <param name="uriAuthority">请求的根URL</param> /// <returns></returns> public static HttpClient GetOrAddClient(string uriAuthority) { uriAuthority = uriAuthority.TrimEnd('/'); var hostUpper = uriAuthority.ToUpper(); HttpClient client = null; if (!Dict.ContainsKey(hostUpper)) { client = HttpClientFactory.Create(innerHandler: new HttpClientHandler { AutomaticDecompression = DecompressionMethods.GZip //, UseCookies = true, //CookieContainer = new CookieContainer() }); try { client.BaseAddress = new Uri(uriAuthority); } catch (Exception ex) { Log.Error("设置HttpClient的Uri出错:" + uriAuthority, ex); return(null); } //client.DefaultRequestHeaders.Accept.Add( // new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.AcceptEncoding.Add( new StringWithQualityHeaderValue("gzip")); var ok = Dict.TryAdd(hostUpper, client); client = !ok?Dict.GetOrAdd(hostUpper, client) : Dict[hostUpper]; } else { client = Dict[hostUpper]; } if (client == null) { Log.ErrorFormat("HttpClient为空:{0}", uriAuthority); } return(client); }
private static async Task <HttpClient> CouchDbClientAsync() { if (httpClient == null) { foreach (DictionaryEntry de in Environment.GetEnvironmentVariables()) { Console.WriteLine(" {0} = {1}", de.Key, de.Value); } string env = Environment.GetEnvironmentVariable(CLOUDANT_SECRET); env = env.Replace("\\", string.Empty); env = env.Replace("'", string.Empty); JObject o = JObject.Parse(env); string host = o.GetValue("host").ToString(); string username = o.GetValue("username").ToString(); string password = o.GetValue("password").ToString(); if (host == null || username == null || password == null) { throw new Exception("Missing Cloudant NoSQL DB service credentials"); } string url = "https://" + host; var authValue = Convert.ToBase64String(Encoding.UTF8.GetBytes(username + ":" + password)); httpClient = HttpClientFactory.Create(); httpClient.BaseAddress = new Uri(url); httpClient.DefaultRequestHeaders.Accept.Clear(); httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authValue); // create Database if not exists var response = await httpClient.PutAsync(dbname, null); if (response.IsSuccessStatusCode) { Console.WriteLine("Database todos created"); } else if (response.StatusCode == HttpStatusCode.PreconditionFailed) //412 database exists { Console.WriteLine("Database todos exists"); } } return(httpClient); }
public async Task <DakiItemHistoryEntry> ObtainItemState(Hunt hunt) { var client = HttpClientFactory.Create(); try { var rawHtml = await client.GetStreamAsync(hunt.HuntedItem.Url); var doc = new HtmlDocument(); doc.Load(rawHtml); var infoSection = doc.DocumentNode.Descendants("div") .First(node => node.HasAttribute("id", "sellInfo_left")); var output = new DakiItemHistoryEntry { DateTime = DateTime.UtcNow, }; if (infoSection.InnerText.Contains("品切れ中です")) { output.IsAvailable = false; output.Price = -1; } else { output.IsAvailable = true; var priceSectionText = infoSection.Descendants("p").First(node => node.HasAttribute("id", "price")).InnerText; var parts = priceSectionText.Split('円'); output.Price = int.Parse(parts[0].Replace(",", "")); } return(output); } catch (Exception e) { _logger.LogError(e, $"Error parsing single surugaya item. Hunt {hunt.Id}, item {hunt.HuntedItem.Id}"); return(null); } }
public static async Task Run([ServiceBusTrigger("khsvrlessohsbtopic", "khsvrlessohsbtopicsub", Connection = "PUBSUBConnection")] string mySbMsg, [Blob("receipts-high-value/{rand-guid}.json", FileAccess.Write, Connection = "AzureWebJobsStorage")] Stream receipt, ILogger log) { log.LogInformation($"C# ServiceBus topic trigger function processed message: {mySbMsg}"); log.LogInformation($"Total Cost is greater than or equal to $100.00 starting..."); dynamic data = JObject.Parse(mySbMsg); try { // Get Receipt in PDF Format log.LogInformation($"PDF Receipt starting..."); HttpClient httpClient = HttpClientFactory.Create(); string responseMessage = String.Empty; HttpResponseMessage pdfResponse = await httpClient.GetAsync((string)data.receiptUrl); byte[] pdfData = null; pdfData = await pdfResponse.Content.ReadAsByteArrayAsync(); string base64PDF = Convert.ToBase64String(pdfData); log.LogInformation($"PDF Receipt completed."); Greater100 greater100 = new Greater100(); greater100.Store = data.storeLocation; greater100.SalesNumber = data.salesNumber; greater100.TotalCost = (double)data.totalCost; greater100.Items = (long)data.totalItems; greater100.SalesDate = data.salesDate; greater100.ReceiptImage = base64PDF; string g100Content = JsonConvert.SerializeObject(greater100); using (Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(g100Content))) { await stream.CopyToAsync(receipt); } } catch (Exception exc) { log.LogError($"Total Cost is greater than $100.00 failed with exception type {exc.GetType().ToString()} and error message: {exc.Message}"); } log.LogInformation($"Total Cost is greater than $100.00 completed."); }
public IHttpClient Create() { var webRequestHandler = new WebRequestHandler(); if (webRequestHandler.SupportsAutomaticDecompression) { webRequestHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate; } #if DEBUG webRequestHandler.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true; #endif _requestHandlerConfigurators.ForEach((configurator) => configurator(webRequestHandler)); var client = _cacheHandler == null ? HttpClientFactory.Create(webRequestHandler, _handlers.ToArray()) : HttpClientFactory.Create(_cacheHandler, _handlers.ToArray()); client.BaseAddress = _baseUrl; if (_connectionLeaseTimeout != 0) { var servicePoint = ServicePointManager.FindServicePoint(_baseUrl); servicePoint.ConnectionLeaseTimeout = _connectionLeaseTimeout; } if (_timeout.HasValue) { client.Timeout = _timeout.Value; } if (_defaultHeaders == null) { return(new HttpClientWrapper(client)); } foreach (var header in _defaultHeaders) { client.DefaultRequestHeaders.Add(header.Key, header.Value); } return(new HttpClientWrapper(client)); }
public async Task Test() { if (RpsTest == 0) { return; } var token = await CreateUserAndObtainToken(GenerateUsername()); var step = Step.Create(GetTestName(), HttpClientFactory.Create(), context => { var request = Http.CreateRequest("POST", $"{Url}/web/api/tasks") .WithHeader("accept", "application/json") .WithHeader("authorization", $"Bearer {token}") .WithBody(JsonContent.Create(new object[] { new { title = "create_task_test", uid = Guid.NewGuid(), } })); return(Http.Send(request, context)); }, timeout: TimeSpan.FromSeconds(Timeout)); var scenario = ScenarioBuilder .CreateScenario(GetTestName(), step) .WithWarmUpDuration(TimeSpan.FromSeconds(5)) .WithLoadSimulations( Simulation.RampPerSec(RpsWarmUp, TimeSpan.FromSeconds(TimeWarmUp)), Simulation.RampPerSec(RpsTest, TimeSpan.FromSeconds(TimeRamp)), Simulation.InjectPerSec(RpsTest, TimeSpan.FromSeconds(TimeTest)) // Simulation.InjectPerSecRandom(RpsMin, RpsMax, TimeSpan.FromSeconds(Time)) ); var result = await RunScenario(scenario); VerifyResults(result); }
public async void API_GetChartsData_Test(string url) { var config = new HttpConfiguration(); RouteConfig.RegisterRoutes(config); AutofacWebApi.Setup(config); var httpServer = new HttpServer(config); var client = HttpClientFactory.Create(innerHandler: httpServer); var response = client.GetAsync(new Uri(url)).Result; //HttpResponseMessage response = await client.GetAsync(new Uri(url)); Assert.Equal(HttpStatusCode.OK, response.StatusCode); var json = JObject.Parse(response.Content.ReadAsStringAsync().Result); var viewModel = json.ToObject <ChartsData>(); Assert.IsType(typeof(ChartsData), viewModel); }
/// <summary> /// Wire up three sample HttpMessageHandler instances to the client which means /// that each request and response will go through these three before hitting the /// network. /// </summary> static async Task RunHttpClientWithHttpClientHandlerAndMultipleDelegatingHandlersAsync() { Console.WriteLine("Issue request using an HttpClient with HttpClientHandler and multiple delegating handlers in the pipeline."); // Create HttpClientHandler and set UseDefaultCredentials property HttpClientHandler clientHandler = new HttpClientHandler(); clientHandler.UseDefaultCredentials = true; // Create an HttpClient and add message handlers for the client HttpClient client = HttpClientFactory.Create( clientHandler, new SampleHandler("Client A", 2), new SampleHandler("Client B", 4), new SampleHandler("Client C", 6)); HttpResponseMessage response = await client.GetAsync(_address); Console.WriteLine("Request completed with status code {0}", response.StatusCode); }
public MuzlanClient(MuzlanClientConfig config) { if (config == null) { throw new ArgumentNullException(nameof(config)); } BaseUri = new Uri(config.Host, UriKind.Absolute); _client = HttpClientFactory.Create(config); _parser = new HtmlParser(); Albums = new AlbumsEndpoint(BaseUri, _client, _parser); Auth = new AuthEndpoint(BaseUri, _client, _parser); Download = new DownloadEndpoint(BaseUri, _client, _parser); Meta = new MetaEndpoint(BaseUri, _client, _parser); Search = new SearchEndpoint(BaseUri, _client, _parser); Sitemap = new SitemapEndpoint(BaseUri, _client, _parser); }
/// <summary> /// 获取自定义菜单 /// </summary> /// <param name="wx"></param> /// <returns></returns> public async Task <string> GetMenu(PublicWX wx) { if (string.IsNullOrEmpty(wx.AccessToken)) { throw new InvalidOperationException("公众号还没有获取Access_Key"); } using (var client = HttpClientFactory.Create()) { string uri = string.Format("https://api.weixin.qq.com/cgi-bin/menu/get?access_token={0}", wx.AccessToken); HttpResponseMessage response = await client.GetAsync(uri); if (response.StatusCode == System.Net.HttpStatusCode.OK) { var ret = await response.Content.ReadAsStringAsync(); return(ret); } return(null); } }
static async Task Main(string[] args) { var httpClient = HttpClientFactory.Create(); var url = "https://jsonplaceholder.typicode.com/todos/1"; //var data = await httpClient.GetStringAsync(url); HttpResponseMessage httpResponseMessage = await httpClient.GetAsync(url); if (httpResponseMessage.StatusCode == HttpStatusCode.OK) { var content = httpResponseMessage.Content; var data = await content.ReadAsStringAsync(); Console.WriteLine(data); } Console.WriteLine("Hello World!"); }
public void DoSimulation(object state) { var httpClient = HttpClientFactory.Create(); httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var random = new Random(); foreach (var vin in Vins) { if (random.Next(5) == 4) { continue; } var request = new HttpRequestMessage(HttpMethod.Post, url); request.Content = new StringContent(JsonConvert.SerializeObject(vin), Encoding.UTF8, "application/json"); var result = httpClient.SendAsync(request); var endResult = result.Result; } }