public async Task ExecuteResultAsync(ActionContext context) { foreach (var item in this) { if (item.Stream != null) { var content = new StreamContent(item.Stream); if (item.ContentType != null) { content.Headers.ContentType = new MediaTypeHeaderValue(item.ContentType); } if (item.FileName != null) { var contentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = item.FileName }; content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = contentDisposition.FileName, FileNameStar = contentDisposition.FileNameStar }; } _content.Add(content); } } context.HttpContext.Response.ContentLength = _content.Headers.ContentLength; context.HttpContext.Response.ContentType = _content.Headers.ContentType !.ToString(); await _content.CopyToAsync(context.HttpContext.Response.Body); }
private static async void Request_POST_MultipartContent(string uri, string raw, string timeKey) { using (var client = new System.Net.Http.HttpClient()) using (var batchRequest = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Post, uri)) { System.Net.Http.MultipartContent batchContent = new System.Net.Http.MultipartContent("batch"); batchRequest.Content = batchContent; batchContent.Add(new System.Net.Http.StringContent(raw, System.Text.Encoding.UTF8, "application/json")); await client.SendAsync(batchRequest).ContinueWith(responseTask => { dicResult.Add(timeKey, responseTask.Result.Content.ReadAsStringAsync().Result); }); } }
public async Task ReadAsAsync_WhenContentIsMultipartContentAndFormatterCanReadFromTheContent() { MultipartContent mimeContent = new MultipartContent(); mimeContent.Add(new StringContent("multipartContent")); _formatterMock.Setup(f => f.CanWriteType(It.IsAny <Type>())).Returns(true); _formatterMock.Setup(f => f.CanReadType(It.IsAny <Type>())).Returns(true); _formatterMock.Setup(f => f.ReadFromStreamAsync(It.IsAny <Type>(), It.IsAny <Stream>(), It.IsAny <HttpContent>(), It.IsAny <IFormatterLogger>())) .Returns <Type, Stream, HttpContent, IFormatterLogger>(async(type, stream, content, logger) => { MultipartMemoryStreamProvider provider = await content.ReadAsMultipartAsync(); Assert.Equal(1, provider.Contents.Count); return(await provider.Contents[0].ReadAsStringAsync()); }); MediaTypeFormatter formatter = _formatterMock.Object; formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/mixed")); Assert.Equal("multipartContent", await mimeContent.ReadAsAsync <string>(new[] { formatter })); }
public void ReadAsMultipartAsyncNestedMultipartContentAsync(string boundary) { const int nesting = 10; const string innerText = "Content"; MultipartContent innerContent = new MultipartContent("mixed", boundary); innerContent.Add(new StringContent(innerText)); for (var cnt = 0; cnt < nesting; cnt++) { string outerBoundary = String.Format("{0}_{1}", boundary, cnt); MultipartContent outerContent = new MultipartContent("mixed", outerBoundary); outerContent.Add(innerContent); innerContent = outerContent; } MemoryStream memStream = new MemoryStream(); innerContent.CopyToAsync(memStream).Wait(); memStream.Position = 0; byte[] data = memStream.ToArray(); HttpContent content = new ByteArrayContent(data); content.Headers.ContentType = innerContent.Headers.ContentType; for (var cnt = 0; cnt < nesting + 1; cnt++) { Task <IEnumerable <HttpContent> > task = content.ReadAsMultipartAsync(); task.Wait(TimeoutConstant.DefaultTimeout); IEnumerable <HttpContent> result = task.Result; Assert.Equal(1, result.Count()); content = result.ElementAt(0); Assert.NotNull(content); } string text = content.ReadAsStringAsync().Result; Assert.Equal(innerText, text); }
public async Task ReadAsMultipartAsync_NestedMultipartContent(string boundary) { const int nesting = 10; const string innerText = "Content"; MultipartContent innerContent = new MultipartContent("mixed", boundary); innerContent.Add(new StringContent(innerText)); for (var cnt = 0; cnt < nesting; cnt++) { string outerBoundary = String.Format("{0}_{1}", boundary, cnt); MultipartContent outerContent = new MultipartContent("mixed", outerBoundary); outerContent.Add(innerContent); innerContent = outerContent; } MemoryStream memStream = new MemoryStream(); await innerContent.CopyToAsync(memStream); memStream.Position = 0; byte[] data = memStream.ToArray(); HttpContent content = new ByteArrayContent(data); content.Headers.ContentType = innerContent.Headers.ContentType; for (var cnt = 0; cnt < nesting + 1; cnt++) { MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync(); Assert.Equal(1, result.Contents.Count); content = result.Contents[0]; Assert.NotNull(content); } string text = await content.ReadAsStringAsync(); Assert.Equal(innerText, text); }
/// <summary> /// <see cref="HttpContent"/> implementation which provides a byte range view over a stream used to generate HTTP /// 206 (Partial Content) byte range responses. If none of the requested ranges overlap with the current extend /// of the selected resource represented by the <paramref name="content"/> parameter then an /// <see cref="InvalidByteRangeException"/> is thrown indicating the valid Content-Range of the content. /// </summary> /// <param name="content">The stream over which to generate a byte range view.</param> /// <param name="range">The range or ranges, typically obtained from the Range HTTP request header field.</param> /// <param name="mediaType">The media type of the content stream.</param> /// <param name="bufferSize">The buffer size used when copying the content stream.</param> public ByteRangeStreamContent(Stream content, RangeHeaderValue range, MediaTypeHeaderValue mediaType, int bufferSize) { if (content == null) { throw Error.ArgumentNull("content"); } if (!content.CanSeek) { throw Error.Argument("content", Properties.Resources.ByteRangeStreamNotSeekable, typeof(ByteRangeStreamContent).Name); } if (range == null) { throw Error.ArgumentNull("range"); } if (mediaType == null) { throw Error.ArgumentNull("mediaType"); } if (bufferSize < MinBufferSize) { throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize); } if (!range.Unit.Equals(SupportedRangeUnit, StringComparison.OrdinalIgnoreCase)) { throw Error.Argument("range", Properties.Resources.ByteRangeStreamContentNotBytesRange, range.Unit, SupportedRangeUnit); } try { // If we have more than one range then we use a multipart/byteranges content type as wrapper. // Otherwise we use a non-multipart response. if (range.Ranges.Count > 1) { // Create Multipart content and copy headers to this content MultipartContent rangeContent = new MultipartContent(ByteRangesContentSubtype); _byteRangeContent = rangeContent; foreach (RangeItemHeaderValue rangeValue in range.Ranges) { try { ByteRangeStream rangeStream = new ByteRangeStream(content, rangeValue); HttpContent rangeBodyPart = new StreamContent(rangeStream, bufferSize); rangeBodyPart.Headers.ContentType = mediaType; rangeBodyPart.Headers.ContentRange = rangeStream.ContentRange; rangeContent.Add(rangeBodyPart); } catch (ArgumentOutOfRangeException) { // We ignore range errors until we check that we have at least one valid range } } // If no overlapping ranges were found then stop if (!rangeContent.Any()) { ContentRangeHeaderValue actualContentRange = new ContentRangeHeaderValue(content.Length); string msg = Error.Format(Properties.Resources.ByteRangeStreamNoneOverlap, range.ToString()); throw new InvalidByteRangeException(actualContentRange, msg); } } else if (range.Ranges.Count == 1) { try { ByteRangeStream rangeStream = new ByteRangeStream(content, range.Ranges.First()); _byteRangeContent = new StreamContent(rangeStream, bufferSize); _byteRangeContent.Headers.ContentType = mediaType; _byteRangeContent.Headers.ContentRange = rangeStream.ContentRange; } catch (ArgumentOutOfRangeException) { ContentRangeHeaderValue actualContentRange = new ContentRangeHeaderValue(content.Length); string msg = Error.Format(Properties.Resources.ByteRangeStreamNoOverlap, range.ToString()); throw new InvalidByteRangeException(actualContentRange, msg); } } else { throw Error.Argument("range", Properties.Resources.ByteRangeStreamContentNoRanges); } // Copy headers from byte range content so that we get the right content type etc. _byteRangeContent.Headers.CopyTo(Headers); _content = content; _start = content.Position; } catch { if (_byteRangeContent != null) { _byteRangeContent.Dispose(); } throw; } }