public static async Task<BerkeleyDtoResult> GetResultAsync(JsonSerializer serializer, HttpContent content) { using (Stream stream = await content.ReadAsStreamAsync().ConfigureAwait(false)) using (var reader = new StreamReader(stream)) using (var jsonReader = new JsonTextReader(reader)) return serializer.Deserialize<BerkeleyDtoResult>(jsonReader); }
public async Task <ActionResult> GetAttachment(int FileID) { UriBuilder uriBuilder = new UriBuilder(); uriBuilder.Scheme = "https"; uriBuilder.Host = "api.example.com"; var Path = "/files/download"; uriBuilder.Path = Path; using (HttpClient client = new HttpClient()) { client.BaseAddress = new Uri(uriBuilder.ToString()); client.DefaultRequestHeaders.Accept.Clear(); //client.DefaultRequestHeaders.Add("authorization", access_token); //if any //client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); HttpResponseMessage response = await client.GetAsync(uriBuilder.ToString()); if (response.IsSuccessStatusCode) { response.Headers[""]; System.Net.Http.HttpContent content = response.Content; var contentStream = await content.ReadAsStreamAsync(); // get the actual content stream return(File(contentStream, content_type, filename)); } else { throw new FileNotFoundException(); } } }
public async Task Download() { var index = 0; for (int i = 0; i < files.Count; i++) { if (files[i] == selectedfile) { index = i; } } if (index != 0) { UploadText.Text = selectedfile + " has been downloaded to [DownloadBook] folder!"; string path = downloadpath + "\\" + selectedfile; Console.Write("\n[{0} has been downloaded to {1}!]", files[index], path); //download file string display = baseUrl_ + "/" + index; var resp2 = await client.GetAsync(baseUrl_ + "/" + index).ConfigureAwait(false); System.Net.Http.HttpContent content = resp2.Content; // actually a System.Net.Http.StreamContent instance but you do not need to cast as the actual type does not matter in this case using (var file = System.IO.File.Create(path)) { // create a new file to write to var contentStream = await content.ReadAsStreamAsync(); // get the actual content stream await contentStream.CopyToAsync(file); // copy that stream to the file stream await file.FlushAsync(); // flush back to disk before disposing } } }
private static async Task GetAttachment(int FileID) { UriBuilder uriBuilder = new UriBuilder(); uriBuilder.Scheme = "https"; uriBuilder.Host = "www1.nseindia.com/content/historical/EQUITIES/2020/MAR/cm04MAR2020bhav.csv.zip"; //https://www1.nseindia.com/content/historical/EQUITIES/2020/MAR/cm04MAR2020bhav.csv.zip var Path = "/files/download"; uriBuilder.Path = Path; using (HttpClient client = new HttpClient()) { client.BaseAddress = new Uri(uriBuilder.ToString()); client.DefaultRequestHeaders.Accept.Clear(); //client.DefaultRequestHeaders.Add("authorization", access_token); //if any //client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); HttpResponseMessage response = await client.GetAsync(uriBuilder.ToString()); if (response.IsSuccessStatusCode) { System.Net.Http.HttpContent content = response.Content; var contentStream = await content.ReadAsStreamAsync(); // get the actual content stream // return File(contentStream, content_type, filename); } else { throw new FileNotFoundException(); } } }
public static async Task GetAttachment(string url, string filename) { UriBuilder uriBuilder = new UriBuilder(url); using (HttpClient client = new HttpClient()) { client.BaseAddress = new Uri(uriBuilder.ToString()); client.DefaultRequestHeaders.Accept.Clear(); HttpResponseMessage response = await client.GetAsync(uriBuilder.ToString()); if (response.IsSuccessStatusCode) { System.Net.Http.HttpContent content = response.Content; var contentStream = await content.ReadAsStreamAsync(); // get the actual content stream using (var outputStream = File.OpenWrite(filename)) { contentStream.CopyTo(outputStream); contentStream.Flush(); } } else { throw new FileNotFoundException(); } } }
public async Task DownloadFile(string route, string filename) { if (File.Exists(filename)) { File.Delete(filename); } var httpClient = await GetHttpClient(); HttpResponseMessage response = await httpClient.GetAsync(route); if (response.IsSuccessStatusCode) { System.Net.Http.HttpContent content = response.Content; var contentStream = await content.ReadAsStreamAsync(); using (var stream = new FileStream(filename, FileMode.Create)) { await contentStream.CopyToAsync(stream); } } else { throw new FileNotFoundException(); } }
HttpContent IHttpContentEncryptor.Encrypt(HttpContent originContent) { if (originContent == null) { throw new ArgumentNullException("originContent"); } var originData = originContent.ReadAsStreamAsync().Result; if (originData.Length == 0) { return originContent; } this.algorithm.Key = this.keyProvider.Key; this.algorithm.IV = this.keyProvider.IV; using (var encryptor = algorithm.CreateEncryptor()) { using (var encryptedData = new MemoryStream()) { var cryptoStream = new CryptoStream(encryptedData, encryptor, CryptoStreamMode.Write); originData.CopyTo(cryptoStream); cryptoStream.FlushFinalBlock(); encryptedData.Position = 0; var encodedString = Convert.ToBase64String(encryptedData.ToArray()); var encryptedContent = new StringContent(encodedString); encryptedContent.Headers.ContentType = originContent.Headers.ContentType; return encryptedContent; } } }
private Location readJsonIntoAddress(HttpContent content) { DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(Response)); Response bingResponse = jsonSerializer.ReadObject(content.ReadAsStreamAsync().Result) as Response; Location bingLocation = bingResponse.ResourceSets[0].Resources[0] as Location; return bingLocation; }
public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger, CancellationToken cancellationToken) { var uf = new UploadedFile(StrHelper.UnquoteToken(content.Headers.ContentDisposition.FileName), await content.ReadAsStreamAsync()); return uf; }
public string ReadResponse(HttpResponseMessage response) { string result = string.Empty; System.Net.Http.HttpContent sm = response.Content; Task <Stream> sr = sm.ReadAsStreamAsync(); Task <string> res = sm.ReadAsStringAsync(); result = res.Result; return(result); }
private static async Task<HttpContent> DecompressContent(HttpContent compressedContent, ICompressor compressor) { using (compressedContent) { MemoryStream decompressed = new MemoryStream(); await compressor.Decompress(await compressedContent.ReadAsStreamAsync(), decompressed); var newContent = new StreamContent(decompressed); // copy content type so we know how to load correct formatter newContent.Headers.ContentType = compressedContent.Headers.ContentType; return newContent; } }
/// <inheritdoc /> public async Task<object> ConvertFromHttpContentAsync(Type resultType, HttpContent httpContent, CancellationToken cancellationToken = default(CancellationToken)) { if (!CanConvertFromHttpContent(resultType, httpContent)) { throw new NotSupportedException("CanConvertFromHttpContent resulted in false, this is not supposed to be called."); } Log.Debug().WriteLine("Retrieving the content as XDocument, Content-Type: {0}", httpContent.Headers.ContentType); using (var contentStream = await httpContent.ReadAsStreamAsync().ConfigureAwait(false)) { return XDocument.Load(contentStream); } }
/// <summary> /// Get all tracks from serverDb /// </summary> /// <returns></returns> public static List <Track> GetTracks() { var responseTask = client.GetAsync("track"); responseTask.Wait(); var result = responseTask.Result; IDictionary <string, dynamic> json = null; if (result.IsSuccessStatusCode) { var readTask = result.Content.ReadAsAsync <IDictionary <string, dynamic> >(); readTask.Wait(); json = readTask.Result; } List <Track> tracks = JsonConvert.DeserializeObject <List <Track> >(json["objects"].ToString()); foreach (var track in tracks) { string[] splitAlbumPath = track.album.Split('/'); track.album = splitAlbumPath[splitAlbumPath.Length - 1]; // < Audio download > var httpResponseMessage = dlClient.GetAsync("song_file/" + track.id + "/"); httpResponseMessage.Wait(); var resp = httpResponseMessage.Result; if (resp.IsSuccessStatusCode) { System.Net.Http.HttpContent content = resp.Content; string format = content.Headers.ContentDisposition.FileName.Split('.')[content.Headers.ContentDisposition.FileName.Split('.').Length - 1]; format = format.Replace("\"", ""); if (format == "wav" || format == "mp3") { Stream contentStream = content.ReadAsStreamAsync().Result; // get the actual content stream string path = new Uri(Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase)).LocalPath + "/Data/Tracks/" + track.title + "." + format; using (FileStream fileStream = File.Create(path)) { contentStream.Seek(0, SeekOrigin.Begin); contentStream.CopyTo(fileStream); track.audio = path; } } } // </ Audio download > } return(tracks); }
private static async Task<HttpContent> DecompressContentAsync(HttpContent compressedContent, ICompressor compressor) { using (compressedContent) { var decompressed = new MemoryStream(); await compressor.Decompress(await compressedContent.ReadAsStreamAsync(), decompressed).ConfigureAwait(true); decompressed.Position = 0; var newContent = new StreamContent(decompressed); newContent.Headers.ContentType = compressedContent.Headers.ContentType; return newContent; } }
public async Task <FileDTO> GetExampleFileAsync() { /* * TODO - esse método poderia ser melhorado. Em vez de ler o arquivo do disco, * seria mais interessante gerar um arquivo de exemplo com as configurações presentes * no appsettings.json referentes à posição e tamanho dos campos. Dessa forma, se mudarmos * o layout do arquivo, não temos que alterar o arquivo de "exemplo". */ FileDTO file = new FileDTO(); file.ContentType = "text/plain"; file.Extension = "txt"; file.Name = "EXAMPLE.txt"; file.Content = new MemoryStream(); if (this._fileServerSettings.Type == "file") { using (FileStream fs = new FileStream(this._fileServerSettings.Path, FileMode.Open, FileAccess.Read)) { await fs.CopyToAsync(file.Content); file.Content.Position = 0; } } else { using (HttpClient client = new HttpClient()) { HttpResponseMessage response = await client.GetAsync(this._fileServerSettings.Path); if (response.IsSuccessStatusCode) { System.Net.Http.HttpContent content = response.Content; var contentStream = await content.ReadAsStreamAsync(); await contentStream.CopyToAsync(file.Content); file.Content.Position = 0; } else { throw new FileNotFoundException("Impossível obter arquivo do servidor"); } } } return(file); }
private static async Task<HttpContent> DecompressContentAsync(HttpContent compressedContent, ICompressor compressor) { using (compressedContent) { MemoryStream decompressed = new MemoryStream(); await compressor.Decompress(await compressedContent.ReadAsStreamAsync(), decompressed).ConfigureAwait(false); // set position back to 0 so it can be read again decompressed.Position = 0; var newContent = new StreamContent(decompressed); // copy content type so we know how to load correct formatter newContent.Headers.ContentType = compressedContent.Headers.ContentType; return newContent; } }
public async Task<object> DeserializeAsync(Type type, HttpContent content) { HttpContentHeaders headers = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (headers != null) { if (headers.ContentLength == 0) return ReflectionHelper.GetDefaultValue(type); var mediaType = headers.ContentType.MediaType; Util.Check(_mediaTypes.Contains(mediaType), "JsonContentSerializer: cannot deserialize response body with content type {0}.", mediaType); } //Get stream var stream = await content.ReadAsStreamAsync(); Encoding effectiveEncoding = SelectCharacterEncoding(headers); using (JsonTextReader jsonTextReader = new JsonTextReader(new StreamReader(stream, effectiveEncoding)) { CloseInput = false, MaxDepth = _maxDepth }) { return _serializer.Deserialize(jsonTextReader, type); } }
public static Object Extract( HttpContent content, Type commandType ) { var read = content.ReadAsAsync( commandType ); read.Wait(); //reset the internal stream position to allow the WebAPI pipeline to read it again. content.ReadAsStreamAsync() .ContinueWith( t => { if( t.Result.CanSeek ) { t.Result.Seek( 0, SeekOrigin.Begin ); } } ) .Wait(); return read.Result; }
private static async Task GetPRStats(List <stat> stats, ht.HttpClient client, string project) { var complete = false; var url = $"https://api.github.com/repos/xBimTeam/{project}/pulls"; int iPage = 1; while (!complete) { // Get the response. var t = url + "?page=" + iPage + "&per_page=30&state=all"; Debug.WriteLine(t); ht.HttpResponseMessage response = await client.GetAsync(t); // Get the response content. ht.HttpContent responseContent = response.Content; // Get the stream of the content. using (var reader = new StreamReader(await responseContent.ReadAsStreamAsync())) { // Write the output. var content = await reader.ReadToEndAsync(); var items = JArray.Parse(content); // JArray comments = (JArray)data["channel"]["item"][0]["category"]; foreach (var item in items) { var user = item["user"]["login"].ToString(); var created = item["created_at"].ToString(); DateTime createdDate = DateTime.Parse(created); var s = new stat() { login = user, date = createdDate, project = project, type = "PR" }; stats.Add(s); } iPage++; complete = (items.Count < 30); } } }
/// <summary> /// Reads all body parts within a MIME multipart message using the provided <see cref="MultipartStreamProvider"/> instance /// to determine where the contents of each body part is written and <paramref name="bufferSize"/> as read buffer size. /// </summary> /// <typeparam name="T">The <see cref="MultipartStreamProvider"/> with which to process the data.</typeparam> /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param> /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param> /// <param name="bufferSize">Size of the buffer used to read the contents.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests.</param> /// <returns>A <see cref="Task{T}"/> representing the tasks of getting the result of reading the MIME content.</returns> public static async Task <T> ReadAsMultipartAsync <T>(this HttpContent content, T streamProvider, int bufferSize, CancellationToken cancellationToken) where T : MultipartStreamProvider { if (content == null) { throw Error.ArgumentNull("content"); } if (streamProvider == null) { throw Error.ArgumentNull("streamProvider"); } if (bufferSize < MinBufferSize) { throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize); } Stream stream; try { stream = await content.ReadAsStreamAsync(); } catch (Exception e) { throw new IOException(Properties.Resources.ReadAsMimeMultipartErrorReading, e); } using (var parser = new MimeMultipartBodyPartParser(content, streamProvider)) { byte[] data = new byte[bufferSize]; MultipartAsyncContext context = new MultipartAsyncContext(stream, parser, data, streamProvider.Contents); // Start async read/write loop await MultipartReadAsync(context, cancellationToken); // Let the stream provider post-process when everything is complete await streamProvider.ExecutePostProcessingAsync(cancellationToken); return(streamProvider); } }
public async Task<string> StoreImage(HttpContent content, string path, int advertId, string userId) { Stream stream = await content.ReadAsStreamAsync(); string fileName = null; try { Image image = Image.FromStream(stream); var extension = ImageFormatUtils.FileExtensionFromEncoder(image.RawFormat); fileName = string.Format("{0}{1}{2}{3}{4}", advertId, userId, DateTime.Now.Ticks, random.Next() % 10000007, extension); var fullPath = Path.Combine(path, fileName); image.Save(fullPath); } catch { throw new InvalidDataException(); } return fileName; }
// There are many helper overloads for ReadAs*(). Provide one worker function to ensure the logic is shared. // // For loosely typed, T = Object, type = specific class. // For strongly typed, T == type.GetType() private static Task <T> ReadAsAsync <T>(HttpContent content, Type type, IEnumerable <MediaTypeFormatter> formatters, IFormatterLogger formatterLogger) { if (content == null) { throw new ArgumentNullException("content"); } if (type == null) { throw new ArgumentNullException("type"); } if (formatters == null) { throw new ArgumentNullException("formatters"); } ObjectContent objectContent = content as ObjectContent; if (objectContent != null && objectContent.Value != null && type.IsAssignableFrom(objectContent.Value.GetType())) { return(TaskHelpers.FromResult((T)objectContent.Value)); } MediaTypeFormatter formatter = null; MediaTypeHeaderValue mediaType = content.Headers.ContentType; if (mediaType != null) { formatter = new MediaTypeFormatterCollection(formatters).FindReader(type, mediaType); } if (formatter == null) { string mediaTypeAsString = mediaType != null ? mediaType.MediaType : Properties.Resources.UndefinedMediaType; throw new InvalidOperationException( RS.Format(Properties.Resources.NoReadSerializerAvailable, type.Name, mediaTypeAsString)); } return(content.ReadAsStreamAsync() .Then(stream => formatter.ReadFromStreamAsync(type, stream, content.Headers, formatterLogger) .Then(value => (T)value))); }
private async ValueTask <Stream> CreateContentReadStreamAsyncCore(bool async, CancellationToken cancellationToken) { if (_contentConsumed) { throw new InvalidOperationException(SR.net_http_content_stream_already_read); } _contentConsumed = true; Stream originalStream; if (async) { originalStream = _originalContent.TryReadAsStream() ?? await _originalContent.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false); } else { originalStream = _originalContent.ReadAsStream(); } return(GetDecompressedStream(originalStream)); }
private static async Task <T> ReadAsAsyncCore <T>( HttpContent content, Type type, IFormatterLogger formatterLogger, MediaTypeFormatter formatter, CancellationToken cancellationToken ) { cancellationToken.ThrowIfCancellationRequested(); Stream stream = await content.ReadAsStreamAsync(); object result = await formatter.ReadFromStreamAsync( type, stream, content, formatterLogger, cancellationToken ); return((T)result); }
public static Task <T> ReadAsMultipartAsync <T>(this HttpContent content, T streamProvider, int bufferSize) where T : MultipartStreamProvider { if (content == null) { throw Error.ArgumentNull("content"); } if (streamProvider == null) { throw Error.ArgumentNull("streamProvider"); } if (bufferSize < MinBufferSize) { throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize); } MimeMultipartBodyPartParser parser = null; return(content.ReadAsStreamAsync().Then(stream => { TaskCompletionSource <bool> taskCompletionSource = new TaskCompletionSource <bool>(); parser = new MimeMultipartBodyPartParser(content, streamProvider); byte[] data = new byte[bufferSize]; MultipartAsyncContext context = new MultipartAsyncContext(content, stream, taskCompletionSource, parser, data, streamProvider.Contents); // Start async read/write loop MultipartReadAsync(context); // Return task and complete when we have run the post processing step. return taskCompletionSource.Task.Then(() => streamProvider.ExecutePostProcessingAsync().ToTask <T>(result: streamProvider)); }).Finally(() => { if (parser != null) { parser.Dispose(); } }, runSynchronously: true)); }
public async Task <string> DownloadDinosaursFile() { HttpClientHandler handler = new HttpClientHandler(); HttpClient client = new HttpClient(handler); try { Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance); handler.UseDefaultCredentials = true; handler.AllowAutoRedirect = true; HttpResponseMessage response = await client.GetAsync(url); response.EnsureSuccessStatusCode(); if (response.IsSuccessStatusCode) { System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance); System.Net.Http.HttpContent content = response.Content; var contentStream = await content.ReadAsStreamAsync(); // get the actual content stream var excelContent = ParseExcel(contentStream); return(JsonConvert.SerializeObject(excelContent)); } } catch (HttpRequestException e) { Console.WriteLine("\nException Caught!"); Console.WriteLine("Message :{0} ", e.Message); } finally { // Need to call dispose on the HttpClient and HttpClientHandler objects // when done using them, so the app doesn't leak resources handler.Dispose(); client.Dispose(); } return(string.Empty); }
HttpContent IHttpContentEncryptor.Encrypt(HttpContent originContent) { if (originContent == null) { throw new ArgumentNullException("originContent"); } var originStream = originContent.ReadAsStreamAsync().Result; if ( originStream.Length == 0) { return originContent; } byte[] originBytes = new byte[originStream.Length]; originStream.Read(originBytes, 0, originBytes.Length); var encodedString = Convert.ToBase64String(originBytes); var encodedContent = new StringContent(encodedString); encodedContent.Headers.ContentType = originContent.Headers.ContentType; return encodedContent; }
private async Task <Stream> FinishGetStreamAsync(Task <HttpResponseMessage> getTask) { HttpResponseMessage httpResponseMessage = await getTask.ConfigureAwait(false); httpResponseMessage.EnsureSuccessStatusCode(); HttpContent content = httpResponseMessage.Content; Stream stream1; if (content != null) { Stream stream2 = content.TryReadAsStream(); if (stream2 == null) { stream2 = await content.ReadAsStreamAsync().ConfigureAwait(false); } stream1 = stream2; } else { stream1 = Stream.Null; } return(stream1); }
private async Task <string> GetStringAsyncCore(Task <HttpResponseMessage> getTask) { using (HttpResponseMessage responseMessage = await getTask.ConfigureAwait(false)) { responseMessage.EnsureSuccessStatusCode(); HttpContent content = responseMessage.Content; if (content != null) { HttpContentHeaders headers = content.Headers; Stream stream = content.TryReadAsStream(); if (stream == null) { stream = await content.ReadAsStreamAsync().ConfigureAwait(false); } using (Stream responseStream = stream) { using (HttpContent.LimitArrayPoolWriteStream buffer = new HttpContent.LimitArrayPoolWriteStream(this._maxResponseContentBufferSize, (long)(int)headers.ContentLength.GetValueOrDefault())) { try { await responseStream.CopyToAsync((Stream)buffer).ConfigureAwait(false); } catch (Exception ex) when(HttpContent.StreamCopyExceptionNeedsWrapping(ex)) { throw HttpContent.WrapStreamCopyException(ex); } if (buffer.Length > 0L) { return(HttpContent.ReadBufferAsString(buffer.GetBuffer(), headers)); } } } headers = (HttpContentHeaders)null; } return(string.Empty); } }
private async Task <string> GetStringAsyncCore(Task <HttpResponseMessage> getTask) { // Wait for the response message. using (HttpResponseMessage responseMessage = await getTask.ConfigureAwait(false)) { // Make sure it completed successfully. responseMessage.EnsureSuccessStatusCode(); // Get the response content. HttpContent c = responseMessage.Content; if (c != null) { #if NET46 return(await c.ReadAsStringAsync().ConfigureAwait(false)); #else HttpContentHeaders headers = c.Headers; // Since the underlying byte[] will never be exposed, we use an ArrayPool-backed // stream to which we copy all of the data from the response. using (Stream responseStream = c.TryReadAsStream() ?? await c.ReadAsStreamAsync().ConfigureAwait(false)) using (var buffer = new HttpContent.LimitArrayPoolWriteStream(_maxResponseContentBufferSize, (int)headers.ContentLength.GetValueOrDefault())) { await responseStream.CopyToAsync(buffer).ConfigureAwait(false); if (buffer.Length > 0) { // Decode and return the data from the buffer. return(HttpContent.ReadBufferAsString(buffer.GetBuffer(), headers)); } } #endif } // No content to return. return(string.Empty); } }
public static async Task GetFileAsync(string url, string mimetype, string filename, DirectoryInfo sagskatalog) { client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue(mimetype)); HttpResponseMessage response = await client.GetAsync(url); if (response.IsSuccessStatusCode) { System.Net.Http.HttpContent content = response.Content; var contentStream = await content.ReadAsStreamAsync(); // get the actual content stream using (var fileStream = File.Create(filename)) { contentStream.CopyTo(fileStream); } } else { _log.Error("Kunne ikke hente fil: " + filename); //Log this as an error throw new FileNotFoundException(response.ReasonPhrase); } return; }
private static async Task BufferRequestBodyAsync(IDictionary<string, object> environment, HttpContent content) { await content.LoadIntoBufferAsync(); // We need to replace the request body with a buffered stream so that other // components can read the stream environment[OwinConstants.RequestBodyKey] = await content.ReadAsStreamAsync(); }
public static async Task<GithubDocument> ParseContent(HttpContent content, LinkFactory linkFactory) { var stream = await content.ReadAsStreamAsync(); return new GithubDocument(stream, linkFactory); }
/// <summary> /// Reads all body parts within a MIME multipart message using the provided <see cref="MultipartStreamProvider"/> instance /// to determine where the contents of each body part is written and <paramref name="bufferSize"/> as read buffer size. /// </summary> /// <typeparam name="T">The <see cref="MultipartStreamProvider"/> with which to process the data.</typeparam> /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param> /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param> /// <param name="bufferSize">Size of the buffer used to read the contents.</param> /// <returns>A <see cref="Task{T}"/> representing the tasks of getting the result of reading the MIME content.</returns> #if NETFX_CORE public static async Task <T> ReadAsMultipartAsync <T>(this HttpContent content, T streamProvider, int bufferSize) where T : MultipartStreamProvider { if (content == null) { throw Error.ArgumentNull("content"); } if (streamProvider == null) { throw Error.ArgumentNull("streamProvider"); } if (bufferSize < MinBufferSize) { throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize); } try { Stream stream = await content.ReadAsStreamAsync(); List <HttpContent> childContents = new List <HttpContent>(); using (var parser = new MimeMultipartBodyPartParser(content, streamProvider)) { byte[] buffer = new byte[bufferSize]; bool finalPart = false; while (!finalPart) { int readCount = await stream.ReadAsync(buffer, 0, buffer.Length); // The parser returns one or more parsed parts, depending on how much data was returned // from the network read. The last part may be incomplete (partial), so we only dispose // of the parts once we know they're finished. Regardless of whether the part is complete // or not, we send the bytes to the desired output stream. We loop back for more data // until we've completely read the complete, final part. foreach (MimeBodyPart part in parser.ParseBuffer(buffer, readCount)) { try { Stream output = part.GetOutputStream(content); foreach (ArraySegment <byte> segment in part.Segments) { await output.WriteAsync(segment.Array, segment.Offset, segment.Count); } if (part.IsComplete) { if (part.HttpContent != null) { childContents.Add(part.HttpContent); } finalPart = part.IsFinal; part.Dispose(); break; } } catch (Exception) { // Clean up the part if we got an error in the middle of parsing, because we normally // won't dispose a part until it's complete. part.Dispose(); throw; } } } // Let the stream provider post-process when everything is complete await streamProvider.ExecutePostProcessingAsync(); return(streamProvider); } } catch (Exception e) { throw new IOException(Properties.Resources.ReadAsMimeMultipartErrorReading, e); } }
public static Task <Stream> ReadAsStreamAsync(this HttpContent httpContent, CancellationToken cancellation = default) { cancellation.ThrowIfCancellationRequested(); return(httpContent.ReadAsStreamAsync()); }
private static async Task <HttpResponseMessage> ReadAsHttpResponseMessageAsyncCore( this HttpContent content, int bufferSize, int maxHeaderSize, CancellationToken cancellationToken ) { cancellationToken.ThrowIfCancellationRequested(); Stream stream = await content.ReadAsStreamAsync(); HttpUnsortedResponse httpResponse = new HttpUnsortedResponse(); HttpResponseHeaderParser parser = new HttpResponseHeaderParser( httpResponse, HttpResponseHeaderParser.DefaultMaxStatusLineSize, maxHeaderSize ); ParserState parseStatus; byte[] buffer = new byte[bufferSize]; int bytesRead = 0; int headerConsumed = 0; while (true) { try { bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken); } catch (Exception e) { throw new IOException(Properties.Resources.HttpMessageErrorReading, e); } try { parseStatus = parser.ParseBuffer(buffer, bytesRead, ref headerConsumed); } catch (Exception) { parseStatus = ParserState.Invalid; } if (parseStatus == ParserState.Done) { // Create and return parsed HttpResponseMessage return(CreateHttpResponseMessage( httpResponse, stream, bytesRead - headerConsumed )); } else if (parseStatus != ParserState.NeedMoreData) { throw Error.InvalidOperation( Properties.Resources.HttpMessageParserError, headerConsumed, buffer ); } else if (bytesRead == 0) { throw new IOException( Properties.Resources.ReadAsHttpMessageUnexpectedTermination ); } } }
/// <summary> /// Creates an array copy of the <paramref name="content"/> without affecting the <see cref="Stream.Position"/> of the original object. /// </summary> private static async Task<byte[]> CloneArrayAsync(HttpContent content) { var result = await content.ReadAsByteArrayAsync(); var stream = await content.ReadAsStreamAsync(); if (stream.CanSeek) stream.Position = 0; return result; }
public static Task <HttpRequestMessage> ReadAsHttpRequestMessageAsync(this HttpContent content, string uriScheme, int bufferSize) { if (content == null) { throw new ArgumentNullException("content"); } if (uriScheme == null) { throw new ArgumentNullException("uriScheme"); } if (!Uri.CheckSchemeName(uriScheme)) { throw new ArgumentException(RS.Format(Properties.Resources.HttpMessageParserInvalidUriScheme, uriScheme, typeof(Uri).Name), "uriScheme"); } if (bufferSize < MinBufferSize) { throw new ArgumentOutOfRangeException("bufferSize", bufferSize, RS.Format(Properties.Resources.ArgumentMustBeGreaterThanOrEqualTo, MinBufferSize)); } HttpMessageContent.ValidateHttpMessageContent(content, true, true); return(content.ReadAsStreamAsync().Then(stream => { HttpUnsortedRequest httpRequest = new HttpUnsortedRequest(); HttpRequestHeaderParser parser = new HttpRequestHeaderParser(httpRequest); ParserState parseStatus; byte[] buffer = new byte[bufferSize]; int bytesRead = 0; int headerConsumed = 0; while (true) { try { bytesRead = stream.Read(buffer, 0, buffer.Length); } catch (Exception e) { throw new IOException(Properties.Resources.HttpMessageErrorReading, e); } try { parseStatus = parser.ParseBuffer(buffer, bytesRead, ref headerConsumed); } catch (Exception) { parseStatus = ParserState.Invalid; } if (parseStatus == ParserState.Done) { return CreateHttpRequestMessage(uriScheme, httpRequest, stream, bytesRead - headerConsumed); } else if (parseStatus != ParserState.NeedMoreData) { throw new IOException(RS.Format(Properties.Resources.HttpMessageParserError, headerConsumed, buffer)); } } })); }
public async Task <IActionResult> DownloadDocument(int?id) { if (id == null) { return(StatusCode(StatusCodes.Status400BadRequest)); } var document = context_.Documents.Find(id); if (document != null) { string filename = document.StoragePath; try { //path: ReadIt/ReadIt/xxx.pdf HttpClient client = new HttpClient(); //find old path HttpResponseMessage resp = await client.GetAsync(baseUrl_).ConfigureAwait(false); var files = new List <string>(); var index = 0; if (resp.IsSuccessStatusCode) { var json = await resp.Content.ReadAsStringAsync().ConfigureAwait(false); JArray jArr = (JArray)JsonConvert.DeserializeObject(json); foreach (var item in jArr) { files.Add(item.ToString()); } } for (int i = 0; i < files.Count; i++) { if (files[i] == document.StoragePath) { index = i; } } if (index != 0) { //download file string display = baseUrl_ + "/" + index; var resp2 = await client.GetAsync(baseUrl_ + "/" + index).ConfigureAwait(false); System.Net.Http.HttpContent content = resp2.Content; // actually a System.Net.Http.StreamContent instance but you do not need to cast as the actual type does not matter in this case string uploadpath = Directory.GetCurrentDirectory(); uploadpath = uploadpath + "\\DownloadBook\\" + document.StoragePath; using (var file = System.IO.File.Create(uploadpath)) { // create a new file to write to var contentStream = await content.ReadAsStreamAsync(); // get the actual content stream await contentStream.CopyToAsync(file); // copy that stream to the file stream await file.FlushAsync(); // flush back to disk before disposing } } } catch { //fail uploading files! //can verify: IsSuccessStatusCode } } return(RedirectToAction("Index")); }
public static async Task<Stream> awaitReadFileContents(HttpContent content) { return await content.ReadAsStreamAsync(); }
private object JsonParser(HttpContent content) { var stream = content.ReadAsStreamAsync().Result; var streamReader = new StreamReader(stream); var textReader = new JsonTextReader(streamReader); try { return JObject.Load(textReader); } catch { return JArray.Load(textReader); } finally { streamReader.Dispose(); } }
private object HtmlParser(HttpContent content) { var stream = content.ReadAsStreamAsync().Result; return CQ.Create(stream); }
private object XmlParser(HttpContent content) { var stream = content.ReadAsStreamAsync().Result; return XElement.Load((Stream)stream); }
public static Task <Stream> ReadAsStreamAsync(this HttpContent content, CancellationToken cancellationToken) { return(content.ReadAsStreamAsync()); }
/// <summary> /// Processes the image given in the <see cref="HttpContent"/> into a <see cref="UserImage"/> object. /// Resizes the image according to the settings given upon instantiation. /// </summary> /// <param name="user">The user who initiated the procedure</param> /// <returns>A processed image file</returns> public async Task<Image> ProcessUserImage(User user, HttpContent fileContent, string description) { using(fileContent) { // Get filename var fullname = Helpers.GetFilename(fileContent.Headers.ContentDisposition.FileName); var filename = fullname.Item1.Replace("\"", string.Empty); var extension = fullname.Item2.Replace("\"", string.Empty); var mime = fileContent.Headers.ContentType.MediaType; using (var fileStream = await fileContent.ReadAsStreamAsync()) { // Retrieve image var originalImage = d.Image.FromStream(fileStream); var format = originalImage.RawFormat; // Convert image to byte array and set file path var originalData = ConvertToByte(originalImage, format); var origData = new Lazy<byte[]>(() => originalData); var origPath = GetPath(user.Username, originalData, extension); // Calculate medium size var mediumWidth = (int)(originalImage.Width * mediumScaleFactor); var mediumHeight = (int)(originalImage.Height * mediumScaleFactor); // Resize image and set file path var previewImage = ResizeImage(originalImage, mediumWidth, mediumHeight); var previewData = ConvertToByte(previewImage, format); var prevData = new Lazy<byte[]>(() => previewData); var prevPath = GetPath(user.Username, previewData, extension); // Calculate height factor & thumbnail height var thumbnailHeightFactor = ((double)(originalImage.Height) / (double)(originalImage.Width)); var thumbnailHeight = (int)(thumbnailWidth * thumbnailHeightFactor); // Resize thumbnail and set file path var thumbnailImage = ResizeImage(originalImage, thumbnailWidth, thumbnailHeight); var thumbnailData = ConvertToByte(thumbnailImage, format); var thumbData = new Lazy<byte[]>(() => thumbnailData); var thumbPath = GetPath(user.Username, thumbnailData, extension); // FileInfos var original = new FileInfo { Data = origData, Path = origPath }; var preview = new FileInfo { Data = prevData, Path = prevPath }; var thumbnail = new FileInfo { Data = thumbData, Path = thumbPath }; // Return the processed image file. Note it has not been saved to the database yet! return new Image { Filename = filename, Extension = extension, MimeType = mime, Description = description, Original = original, Preview = preview, Thumbnail = thumbnail, Owner = user, Uploaded = DateTime.Now, }; } } }
/// <summary> /// Read and deserialize the HttpContent streaming content /// </summary> /// <typeparam name="T"></typeparam> /// <param name="content"></param> /// <returns></returns> public static async Task <T> ReadAsAsync <T>(this HttpContent content) => await JsonSerializer.DeserializeAsync <T>(await content.ReadAsStreamAsync().ConfigureAwait(false)).ConfigureAwait(false);
private async Task<Response> DeserializeResponse(Request request, HttpContent content, Type bodyType) { using (Stream contentStream = await content.ReadAsStreamAsync()) { using (var reader = new StreamReader(contentStream, Encoding.UTF8, false, DefaultBufferSize, true)) { return DeserializeResponseXml(request, reader, bodyType); } } }
public static Task <HttpResponseMessage> ReadAsHttpResponseMessageAsync(this HttpContent content, int bufferSize, int maxHeaderSize) { if (content == null) { throw Error.ArgumentNull("content"); } if (bufferSize < MinBufferSize) { throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize); } if (maxHeaderSize < InternetMessageFormatHeaderParser.MinHeaderSize) { throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxHeaderSize", maxHeaderSize, InternetMessageFormatHeaderParser.MinHeaderSize); } HttpMessageContent.ValidateHttpMessageContent(content, false, true); return(content.ReadAsStreamAsync().Then(stream => { HttpUnsortedResponse httpResponse = new HttpUnsortedResponse(); HttpResponseHeaderParser parser = new HttpResponseHeaderParser(httpResponse, HttpResponseHeaderParser.DefaultMaxStatusLineSize, maxHeaderSize); ParserState parseStatus; byte[] buffer = new byte[bufferSize]; int bytesRead = 0; int headerConsumed = 0; while (true) { try { bytesRead = stream.Read(buffer, 0, buffer.Length); } catch (Exception e) { throw new IOException(Properties.Resources.HttpMessageErrorReading, e); } try { parseStatus = parser.ParseBuffer(buffer, bytesRead, ref headerConsumed); } catch (Exception) { parseStatus = ParserState.Invalid; } if (parseStatus == ParserState.Done) { // Create and return parsed HttpResponseMessage return CreateHttpResponseMessage(httpResponse, stream, bytesRead - headerConsumed); } else if (parseStatus != ParserState.NeedMoreData) { throw Error.InvalidOperation(Properties.Resources.HttpMessageParserError, headerConsumed, buffer); } } })); }
/// <summary> /// Serialize the HTTP content and return a stream that represents the content as a synchronous operation. /// </summary> public static Stream ReadAsStream(this HttpContent content) { return(Task.Run(() => content.ReadAsStreamAsync()).Result); }
public XElementContent(HttpContent content) { _Element = XElement.Load(content.ReadAsStreamAsync().Result); }
DbEmdFile CreateDbFile(HttpContent ctnt, Stream stream) { DbEmdFile dbFile = new DbEmdFile(); dbFile.ApplicationUserID = User.Identity.GetUserId(); // You would get hold of the inner memory stream here stream = ctnt.ReadAsStreamAsync().Result; dbFile.Content = stream.StreamToByteArray(); dbFile.ContentType = ctnt.Headers.ContentType.MediaType; dbFile.FileName = ctnt.Headers.ContentDisposition.FileName; dbFile.FileSize = (long)ctnt.Headers.ContentLength; return dbFile; }
private static async Task BufferRequestBodyAsync(IOwinRequest owinRequest, HttpContent content) { await content.LoadIntoBufferAsync(); // We need to replace the request body with a buffered stream so that other // components can read the stream owinRequest.Body = await content.ReadAsStreamAsync(); }
internal static async Task<rt.IHttpContent> GetContentFromNet(HttpContent content) { if (content == null) return null; var stream = await content.ReadAsStreamAsync().ConfigureAwait(false); var c = new rt.HttpStreamContent(stream.AsInputStream()); CopyHeaders(content.Headers, c.Headers); return c; }
private static async Task <RTIHttpContent> CreateRequestContentAsync(HttpRequestMessage request, HttpRequestHeaderCollection rtHeaderCollection) { HttpContent content = request.Content; RTIHttpContent rtContent; ArraySegment <byte> buffer; // If we are buffered already, it is more efficient to send the data directly using the buffer with the // WinRT HttpBufferContent class than using HttpStreamContent. This also avoids issues caused by // a design limitation in the System.Runtime.WindowsRuntime System.IO.NetFxToWinRtStreamAdapter. if (content.TryGetBuffer(out buffer)) { rtContent = new RTHttpBufferContent(buffer.Array.AsBuffer(), (uint)buffer.Offset, (uint)buffer.Count); } else { Stream contentStream = await content.ReadAsStreamAsync().ConfigureAwait(false); if (contentStream is RTIInputStream) { rtContent = new RTHttpStreamContent((RTIInputStream)contentStream); } else if (contentStream is MemoryStream) { var memStream = contentStream as MemoryStream; if (memStream.TryGetBuffer(out buffer)) { rtContent = new RTHttpBufferContent(buffer.Array.AsBuffer(), (uint)buffer.Offset, (uint)buffer.Count); } else { byte[] byteArray = memStream.ToArray(); rtContent = new RTHttpBufferContent(byteArray.AsBuffer(), 0, (uint)byteArray.Length); } } else { rtContent = new RTHttpStreamContent(contentStream.AsInputStream()); } } // RTHttpBufferContent constructor automatically adds a Content-Length header. RTHttpStreamContent does not. // Clear any 'Content-Length' header added by the RTHttp*Content objects. We need to clear that now // and decide later whether we need 'Content-Length' or 'Transfer-Encoding: chunked' headers based on the // .NET HttpRequestMessage and Content header collections. rtContent.Headers.ContentLength = null; // Deal with conflict between 'Content-Length' vs. 'Transfer-Encoding: chunked' semantics. // Desktop System.Net allows both headers to be specified but ends up stripping out // 'Content-Length' and using chunked semantics. The WinRT APIs throw an exception so // we need to manually strip out the conflicting header to maintain app compatibility. if (request.Headers.TransferEncodingChunked.HasValue && request.Headers.TransferEncodingChunked.Value) { content.Headers.ContentLength = null; } else { // Trigger delayed header generation via TryComputeLength. This code is needed due to an outstanding // bug in HttpContentHeaders.ContentLength. See GitHub Issue #5523. content.Headers.ContentLength = content.Headers.ContentLength; } foreach (KeyValuePair <string, IEnumerable <string> > headerPair in content.Headers) { foreach (string value in headerPair.Value) { if (!rtContent.Headers.TryAppendWithoutValidation(headerPair.Key, value)) { // rtContent headers are restricted to a white-list of allowed headers, while System.Net.HttpClient's content headers // will allow custom headers. If something is not successfully added to the content headers, try adding them to the standard headers. bool success = rtHeaderCollection.TryAppendWithoutValidation(headerPair.Key, value); Debug.Assert(success); } } } return(rtContent); }
private async Task <byte[]> GetByteArrayAsyncCore(Task <HttpResponseMessage> getTask) { using (HttpResponseMessage responseMessage = await getTask.ConfigureAwait(false)) { responseMessage.EnsureSuccessStatusCode(); HttpContent content = responseMessage.Content; if (content != null) { HttpContentHeaders headers = content.Headers; Stream stream = content.TryReadAsStream(); if (stream == null) { stream = await content.ReadAsStreamAsync().ConfigureAwait(false); } using (Stream responseStream = stream) { long? contentLength = headers.ContentLength; Stream buffer; if (contentLength.HasValue) { buffer = (Stream) new HttpContent.LimitMemoryStream(this._maxResponseContentBufferSize, (int)contentLength.GetValueOrDefault()); try { await responseStream.CopyToAsync(buffer).ConfigureAwait(false); } catch (Exception ex) when(HttpContent.StreamCopyExceptionNeedsWrapping(ex)) { throw HttpContent.WrapStreamCopyException(ex); } if (buffer.Length > 0L) { return(((HttpContent.LimitMemoryStream)buffer).GetSizedBuffer()); } } else { buffer = (Stream) new HttpContent.LimitArrayPoolWriteStream(this._maxResponseContentBufferSize); try { try { await responseStream.CopyToAsync(buffer).ConfigureAwait(false); } catch (Exception ex) when(HttpContent.StreamCopyExceptionNeedsWrapping(ex)) { throw HttpContent.WrapStreamCopyException(ex); } if (buffer.Length > 0L) { return(((HttpContent.LimitArrayPoolWriteStream)buffer).ToArray()); } } finally { buffer.Dispose(); } } buffer = (Stream)null; } headers = (HttpContentHeaders)null; } return(Array.Empty <byte>()); } }