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;
}
}
