internal static async Task <Template> ReadTemplate(MultipartSection section) { var content = new StreamContent(section.Body); var text = await content.ReadAsStringAsync(); return(TemplateSerializer.Deserialize(new StringReader(text)) as Template); }
private async Task <string> GetRequestBodyContentAsync() { var streamContent = new StreamContent(this.HttpContext.Request.Body); var stringContent = await streamContent.ReadAsStringAsync(); return(stringContent); }
public static async Task ParseFiles(Stream data, string contentType, Action <string, Stream> fileProcessor) { var streamCotent = new StreamContent(data); streamCotent.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType); if (streamCotent.IsMimeMultipartContent()) { var provider = await streamCotent.ReadAsMultipartAsync(); foreach (var httpContent in provider.Contents) { var filename = httpContent.Headers.ContentDisposition.FileName; using (var fileContents = await httpContent.ReadAsStreamAsync()) { if (string.IsNullOrWhiteSpace(filename)) { fileProcessor(httpContent.Headers.ContentDisposition.Name.Trim('\"'), fileContents); continue; } fileProcessor(filename.Trim('\"'), fileContents); } } } else { var formdata = await streamCotent.ReadAsFormDataAsync(); var str = await streamCotent.ReadAsStringAsync(); var stream = await streamCotent.ReadAsStreamAsync(); } }
private void PostLoggingEvent(LoggingEvent[] loggingEvents) { var formatter = new LokiBatchFormatter(labels); var httpClient = new LokiHttpClient(TrustSelfCignedCerts); if (httpClient is LokiHttpClient c) { LokiCredentials credentials; if (!string.IsNullOrEmpty(BasicAuthUserName) && !string.IsNullOrEmpty(BasicAuthPassword)) { credentials = new BasicAuthCredentials(ServiceUrl, BasicAuthUserName, BasicAuthPassword); } else { credentials = new NoAuthCredentials(ServiceUrl); } c.SetAuthCredentials(credentials); } using (MemoryStream ms = new MemoryStream()) using (var sc = new StreamWriter(ms)) { formatter.Format(loggingEvents, sc); sc.Flush(); ms.Position = 0; var content = new StreamContent(ms); var contentStr = content.ReadAsStringAsync().Result; // TO VERIFY httpClient.PostAsync(LokiRouteBuilder.BuildPostUri(ServiceUrl), content); } }
public void WriteToStreamAsync_SetsMetadataUriWithSelectClause_OnODataWriterSettings() { // Arrange MemoryStream stream = new MemoryStream(); StreamContent content = new StreamContent(stream); content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json"); IEdmModel model = CreateModel(); IEdmSchemaType entityType = model.FindDeclaredType("System.Net.Http.Formatting.SampleType"); IEdmStructuralProperty property = ((IEdmStructuredType)entityType).FindProperty("Number") as IEdmStructuralProperty; HttpRequestMessage request = CreateFakeODataRequest(model); request.RequestUri = new Uri("http://localhost/sampleTypes?$select=Number"); request.ODataProperties().SelectExpandClause = new SelectExpandClause( new Collection <SelectItem> { new PathSelectItem(new ODataSelectPath(new PropertySegment(property))), }, allSelected: false); ODataMediaTypeFormatter formatter = CreateFormatter(model, request, ODataPayloadKind.Resource); // Act formatter.WriteToStreamAsync(typeof(SampleType[]), new SampleType[0], stream, content, transportContext: null); // Assert stream.Seek(0, SeekOrigin.Begin); string result = content.ReadAsStringAsync().Result; JObject obj = JObject.Parse(result); Assert.Equal("http://localhost/$metadata#sampleTypes(Number)", obj["@odata.context"]); }
public static async Task <CharacterInfo> GetCharacterInfoAsync(string token, CancellationToken cancel_token) { using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token); client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("Hyperwave", "1.0")); HttpResponseMessage msg; try { msg = await client.GetAsync("https://login.eveonline.com/oauth/verify", cancel_token); } catch (Exception) { return(null); } if (!msg.IsSuccessStatusCode) { return(null); } StreamContent stream = msg.Content as StreamContent; string text = await stream.ReadAsStringAsync(); return(JsonConvert.DeserializeObject <CharacterInfo>(text)); } }
public async Task <ObjectResult> JavaPlayGround() { var streamContent = new StreamContent(Request.Body); var codeSnippet = await streamContent.ReadAsStringAsync(); var mainFilePath = $"{JavaFolder}src/main/java/JavaConsole/App.java"; SnippetRunner.FileSplicer(mainFilePath, codeSnippet); var gradle = SnippetRunner.FindExecutable("gradle.exe"); string returnString; if (string.IsNullOrEmpty(gradle))//we are in linux { var buildResponse = SnippetRunner.RunCommand(null, $"./gradlew build", JavaFolder); var runResponse = SnippetRunner.RunCommand(null, "./gradlew run", JavaFolder); returnString = buildResponse + "\r\n\r\n\r\n" + runResponse; } else//we are running in a windows environment { var buildResponse = SnippetRunner.RunCommand(gradle, "build", JavaFolder); var runResponse = SnippetRunner.RunCommand(gradle, "run", JavaFolder); returnString = buildResponse + "\r\n\r\n\r\n" + runResponse; } return(new OkObjectResult(returnString)); }
public async Task <ObjectResult> CsharpPlayGround() { var streamContent = new StreamContent(Request.Body); var codeSnippet = await streamContent.ReadAsStringAsync(); var mainFilePath = $"{ProjectFolder}Program.cs"; SnippetRunner.FileSplicer(mainFilePath, codeSnippet); var dotnet = SnippetRunner.FindExecutable("dotnet.exe"); string returnString; if (string.IsNullOrEmpty(dotnet))//we are in linux { var buildResponse = SnippetRunner.RunCommand(null, $"dotnet build {ProjectFolder}ConsoleApp.csproj", null); var runResponse = SnippetRunner.RunCommand(null, "dotnet run", ProjectFolder); returnString = buildResponse + "\r\n\r\n\r\n" + runResponse; } else//we are running in a windows environment { var buildResponse = SnippetRunner.RunCommand("dotnet", "build", ProjectFolder); var runResponse = SnippetRunner.RunCommand(dotnet, "run", ProjectFolder); returnString = buildResponse + "\r\n\r\n\r\n" + runResponse; } return(new OkObjectResult(returnString)); }
private Boolean IsTreePage(Int32 id) { NetworkCredential credential = new NetworkCredential(_config.ConfluenceSettings.Login, _config.ConfluenceSettings.Password); var handler = new HttpClientHandler { Credentials = credential }; using (var client = new HttpClient(handler)) { client.BaseAddress = new Uri(_config.ConfluenceSettings.Url); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var response = client.GetAsync(String.Format("wiki/rest/api/content/{0}/child/page?os_authType=basic", id)); if (response.Result.IsSuccessStatusCode) { StreamContent content = (StreamContent)response.Result.Content; var task = content.ReadAsStringAsync(); String stringContent = task.Result; dynamic results = JObject.Parse(stringContent); if (results.size != null) { return(results.size.Value > 0); } } } return(false); }
public void WriteToStreamAsync_SetsMetadataUriWithSelectClause_OnODataWriterSettings() { // Arrange MemoryStream stream = new MemoryStream(); StreamContent content = new StreamContent(stream); content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json"); IEdmModel model = CreateModel(); HttpRequestMessage request = CreateFakeODataRequest(model); request.RequestUri = new Uri("http://localhost/Customers?$select=something"); request.SetSelectExpandClause(new SelectExpandClause(new SelectItem[0], allSelected: true)); ODataMediaTypeFormatter formatter = CreateFormatter(model, request, ODataPayloadKind.Entry); // Act formatter.WriteToStreamAsync(typeof(SampleType[]), new SampleType[0], stream, content, transportContext: null); // Assert // This is ugly, but ODataWriter doesn't expose the writer settings that it uses. So, validate that // the $select clause shows up in the response payload. stream.Seek(0, SeekOrigin.Begin); string result = content.ReadAsStringAsync().Result; Assert.Contains("$select=something", result); }
private Task <string> StreamToString(Stream stream) { var content = new StreamContent(stream); stream.Position = 0; return(content.ReadAsStringAsync()); }
public static async Task <string> SerializeAsync <T>(this MediaTypeFormatter formatter, T value) { Stream stream = new MemoryStream(); var content = new StreamContent(stream); formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait(); stream.Position = 0; return(await content.ReadAsStringAsync()); }
public async Task <PayResult> Pay(string paytype) { var stream = await this.httpClient.GetStreamAsync("all.json"); using (StreamContent streamContent = new StreamContent(stream)) { return(new PayResult($"{ paytype }---{await streamContent.ReadAsStringAsync()}")); } }
private static void Main(string[] args) { const int TotalRun = 10 * 1000; var customerController = new CustomerController(); var orderController = new OrderController(); var customer = customerController.Get(1); var orders = new List <Order>(); foreach (var orderId in customer.OrderIds) { orders.Add(orderController.Get(1, orderId)); } var fullCustomer = new FullCustomer(customer) { Orders = orders }; var s = JsonConvert.SerializeObject(fullCustomer); var bytes = Encoding.UTF8.GetBytes(s); var stream = new MemoryStream(bytes); var content = new StreamContent(stream); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var stopwatch = Stopwatch.StartNew(); for (int i = 1; i < TotalRun + 1; i++) { var a = content.ReadAsAsync <FullCustomer>().Result; if (i % 100 == 0) { Console.Write("\r" + i); } } Console.WriteLine(); Console.WriteLine(stopwatch.Elapsed); stopwatch.Restart(); for (int i = 1; i < TotalRun + 1; i++) { var sa = content.ReadAsStringAsync().Result; var a = JsonConvert.DeserializeObject <FullCustomer>(sa); if (i % 100 == 0) { Console.Write("\r" + i); } } Console.WriteLine(); Console.WriteLine(stopwatch.Elapsed); Console.Read(); }
private ICollection <PageModel> GetUserManualPages(Int32 id) { var pages = new List <PageModel>(); NetworkCredential credential = new NetworkCredential(_config.ConfluenceSettings.Login, _config.ConfluenceSettings.Password); var handler = new HttpClientHandler { Credentials = credential }; using (var client = new HttpClient(handler)) { client.BaseAddress = new Uri(_config.ConfluenceSettings.Url); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var response = client.GetAsync(String.Format("wiki/rest/api/content/{0}/child/page?os_authType=basic", id)); if (response.Result.IsSuccessStatusCode) { StreamContent content = (StreamContent)response.Result.Content; var task = content.ReadAsStringAsync(); String stringContent = task.Result; dynamic results = JObject.Parse(stringContent); var regex = new Regex("\\[([^)]*)\\] "); if (results.results != null) { if (results.results.Type == JTokenType.Array && results.results.Count > 0) { foreach (var result in results.results) { var pageId = Int32.Parse(result.id.Value); var pageTitle = regex.Replace((result.title.Value as String).Replace(".", "%2E"), String.Empty); var subPages = new List <PageModel>(); var pageContent = String.Empty; if (IsTreePage(pageId)) { subPages = GetUserManualPages(pageId); } else { pageContent = GetUserManualPageContent(pageId); } pages.Add(new PageModel { Content = pageContent, Id = pageId, Title = pageTitle, Pages = subPages }); } } } } } return(pages); }
private static string Serialize <T>(MediaTypeFormatter formatter, T value) { var stream = new MemoryStream(); var content = new StreamContent(stream); formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait(); stream.Position = 0; return(content.ReadAsStringAsync().Result); }
public static void UsingStreamContent() { // When you have a stream of data, StreamContent is your best bet. var bytes = Encoding.ASCII.GetBytes(Helpers.__); var stream = new MemoryStream(bytes); var content = new StreamContent(stream); var body = content.ReadAsStringAsync().Result; Helpers.AssertEquality("Hello, stream!", body); }
public static string Serialize <T>(T value, MessageMediaTypes mediaType = MessageMediaTypes.Json) { var formatter = (mediaType == MessageMediaTypes.Json) ? (MediaTypeFormatter) new JsonMediaTypeFormatter() : (MediaTypeFormatter) new XmlMediaTypeFormatter(); Stream stream = new MemoryStream(); var content = new StreamContent(stream); formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait(); stream.Position = 0; return(content.ReadAsStringAsync().Result); }
private string SerializeCollection <T>(MediaTypeFormatter formatter, IEnumerable <T> value, MediaTypeHeaderValue mediaType) { Stream stream = new MemoryStream(); HttpContent content = new StreamContent(stream); content.Headers.ContentType = mediaType; formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait(); stream.Position = 0; return(content.ReadAsStringAsync().Result); }
protected string Serialize <T>(MediaTypeFormatter formatter, T value) { // Create a dummy HTTP Content. Stream stream = new MemoryStream(); var content = new StreamContent(stream); /// Serialize the object. formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait(); // Read the serialized string. stream.Position = 0; return(content.ReadAsStringAsync().Result); }
private async Task <string> AddVersion(UserConfiguration uc, CancellationToken cancelToken) { string versionID = ""; Dictionary <string, string> formParms = new Dictionary <string, string>(); formParms.Add("bundle_version", _appInfo.Version); FormUrlEncodedContent paramContent = new FormUrlEncodedContent(formParms); HttpClient client = HttpClientFactory.Create(); client.DefaultRequestHeaders.Add("X-HockeyAppToken", uc.UserToken); HttpResponseMessage response = await client.PostAsync(uc.ApiBase + "apps/" + _appInfo.PublicID + "/app_versions/new", paramContent, cancelToken); if (response.StatusCode == HttpStatusCode.Created) { StreamContent sr = response.Content as StreamContent; string result = await sr.ReadAsStringAsync(); JavaScriptSerializer serializer = new JavaScriptSerializer(); dynamic responseInfo = serializer.Deserialize <object>(result); versionID = ((Dictionary <string, object>)responseInfo)["id"].ToString(); } else { StreamContent sr = response.Content as StreamContent; string result = await sr.ReadAsStringAsync(); JavaScriptSerializer serializer = new JavaScriptSerializer(); dynamic responseInfo = serializer.Deserialize <object>(result); Dictionary <string, object> errors = responseInfo["errors"]; StringBuilder message = new StringBuilder(); message.AppendLine(response.ReasonPhrase); foreach (string key in errors.Keys) { object[] values = (object[])errors[key]; string val = ""; foreach (object obj in values) { val += obj.ToString() + ", "; } if (val.Length > -2) { val = val.Substring(0, val.Length - 2); } message.AppendLine(key + ":" + val); } throw new Exception(message.ToString()); } return(versionID); }
public void ReadAsString() { var ms = new MemoryStream(); ms.WriteByte(77); ms.WriteByte(55); ms.Seek(0, SeekOrigin.Begin); var sc = new StreamContent(ms); var res = sc.ReadAsStringAsync().Result; Assert.AreEqual("M7", res, "#1"); }
public async Task ReplaceAsync(HttpRequestMessage target, HttpRequest source, ReplaceString[] replacements) { using (var content = new StreamContent(source.Body)) { var result = await content.ReadAsStringAsync(); foreach (var replacement in replacements) { result = result.Replace(replacement.OldValue, replacement.NewValue); } target.Content = new StringContent(result); } }
public async Task <dynamic> DownloadJsonData(DataLakeFileSystemClient fileSystemClient, string directory, string filePath) { DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient(directory); DataLakeFileClient fileClient = directoryClient.GetFileClient(filePath); Response <FileDownloadInfo> downloadResponse = await fileClient.ReadAsync(); var streamContent = new StreamContent(downloadResponse.Value.Content); var stringContent = await streamContent.ReadAsStringAsync(); return(JsonConvert.DeserializeObject <dynamic>(stringContent)); }
public async Task StreamContent_can_be_used_when_content_is_in_a_stream() { const string thisFileName = @"..\..\HttpContentFacts.cs"; var stream = new FileStream(thisFileName, FileMode.Open, FileAccess.Read); using (var content = new StreamContent(stream)) { content.Headers.ContentType = new MediaTypeHeaderValue("text/plain"); // Assert var text = await content.ReadAsStringAsync(); Assert.True(text.Contains("this string")); } Assert.Throws <ObjectDisposedException>(() => stream.Read(new byte[1], 0, 1)); }
/// <summary> /// Serializa o objeto em string /// </summary> /// <typeparam name="T">Tipo real desse objeto</typeparam> /// <param name="formatter">Instância de um MediaTypeFormatter</param> /// <returns></returns> public static async Task <string> Serialize <T>(this Object instance, MediaTypeFormatter formatter) { // Create a dummy HTTP Content. using (Stream stream = new MemoryStream()) { using (var content = new StreamContent(stream)) { /// Serialize the object. await formatter.WriteToStreamAsync(typeof(T), instance, stream, content, null); // Read the serialized string. stream.Position = 0; return(await content.ReadAsStringAsync()); } } }
public void Delete(string ApiToken, string url) { string userpass = ApiToken + ":api_token"; string userpassB64 = Convert.ToBase64String(Encoding.Default.GetBytes(userpass.Trim())); HttpClient httpClient = new HttpClient(); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", userpassB64); Task <HttpResponseMessage> task = httpClient.DeleteAsync(url); task.Wait(); HttpResponseMessage result = task.Result; StreamContent content = result.Content as StreamContent; var readAsStringTask = content.ReadAsStringAsync(); readAsStringTask.Wait(); string contentStringResult = readAsStringTask.Result; }
public async Task <IActionResult> CreateComposeApp([FromRoute] string name, IFormCollection formData) { var composeFile = formData.Files.FirstOrDefault(f => f.FileName.EndsWith(".yml")); if (composeFile == null) { return(BadRequest()); } var streamContent = new StreamContent(composeFile.OpenReadStream()); var composeFileContent = await streamContent.ReadAsStringAsync(); var composeApplication = new ComposeApplication(name, composeFileContent); await _clusterManager.CreateComposeApp(composeApplication); return(Ok(new { result = $"Application {name} created" })); }
private async Task <String> GetContentAsync(Int32 id, Func <Int32, String, String> parser) { if (_cache.ContainsKey(id)) { return(parser(id, _cache[id])); } var plainTextBytes = System.Text.Encoding.UTF8.GetBytes( $"{_config.ConfluenceSettings.Login}:{_config.ConfluenceSettings.Password}"); var base64Auth = System.Convert.ToBase64String(plainTextBytes); NetworkCredential credential = new NetworkCredential(_config.ConfluenceSettings.Login, _config.ConfluenceSettings.Password); ServicePointManager.Expect100Continue = true; ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(AcceptAllCertifications); ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback(AlwaysGoodCertificate); var handler = new HttpClientHandler { Credentials = credential }; using (var client = new HttpClient(handler)) { client.BaseAddress = new Uri(_config.ConfluenceSettings.Url); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", base64Auth); var response = client.GetAsync($"wiki/rest/api/content/{id}?expand=body.view&os_authType=basic"); if (response.Result.IsSuccessStatusCode) { StreamContent content = (StreamContent)response.Result.Content; var task = content.ReadAsStringAsync(); String result = task.Result; String parsed = parser(id, result); return(parsed); } } throw new ContentNotFoundException(id); }
public static async Task <TokenInfo> GetTokenInfoAsync(string authcode, string challenge_code, CancellationToken token) { using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("Hyperwave", "1.0")); HttpContent content = new FormUrlEncodedContent(new Dictionary <string, string>() { { "grant_type", "authorization_code" }, { "code", authcode }, { "client_id", SSOConfiguration.ClientId }, { "code_verifier", challenge_code } }); DateTime tm = DateTime.Now; HttpResponseMessage msg; try { msg = await client.PostAsync("https://login.eveonline.com/v2/oauth/token", content, token); } catch (Exception) { return(null); } if (!msg.IsSuccessStatusCode) { return(null); } StreamContent stream = msg.Content as StreamContent; string text = await stream.ReadAsStringAsync(); var ret = JsonConvert.DeserializeObject <TokenInfo>(text); ret.LoginDate = tm; return(ret); } }