public void ToString_UseDifferentMediaTypes_AllSerializedCorrectly()
{
var mediaType = new MediaTypeHeaderValue("text/plain");
Assert.Equal("text/plain", mediaType.ToString());
mediaType.Charset = "utf-8";
Assert.Equal("text/plain; charset=utf-8", mediaType.ToString());
mediaType.Parameters.Add(new NameValueHeaderValue("custom", "\"custom value\""));
Assert.Equal("text/plain; charset=utf-8; custom=\"custom value\"", mediaType.ToString());
mediaType.Charset = null;
Assert.Equal("text/plain; custom=\"custom value\"", mediaType.ToString());
}
public async static Task ReturnScript(HttpContext context, string scriptKey, string contentType)
{
var dynamicScript = DynamicScriptManager.GetScript(scriptKey);
if (dynamicScript == null)
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
await context.Response.WriteAsync("File not found!");
}
var mediaType = new MediaTypeHeaderValue(contentType);
mediaType.Encoding = System.Text.Encoding.UTF8;
context.Response.ContentType = mediaType.ToString();
var responseHeaders = context.Response.GetTypedHeaders();
var cacheControl = responseHeaders.CacheControl = new CacheControlHeaderValue();
cacheControl.MaxAge = TimeSpan.FromDays(365);
cacheControl.Private = true;
cacheControl.MustRevalidate = false;
var supportsGzip = dynamicScript.CompressedBytes != null &&
context.Request.GetTypedHeaders().AcceptEncoding.ToString()
.IndexOf("gzip", StringComparison.OrdinalIgnoreCase) >= 0;
byte[] contentBytes;
if (supportsGzip)
{
context.Response.Headers["Content-Encoding"] = "gzip";
contentBytes = dynamicScript.CompressedBytes;
}
else
contentBytes = dynamicScript.UncompressedBytes;
await WriteWithIfModifiedSinceControl(context, contentBytes, dynamicScript.Time);
}
/// <summary>
/// Asynchronously renders the specified <paramref name="view"/> to the response body.
/// </summary>
/// <param name="view">The <see cref="IView"/> to render.</param>
/// <param name="actionContext">The <see cref="ActionContext"/> for the current executing action.</param>
/// <param name="viewData">The <see cref="ViewDataDictionary"/> for the view being rendered.</param>
/// <param name="tempData">The <see cref="ITempDataDictionary"/> for the view being rendered.</param>
/// <returns>A <see cref="Task"/> that represents the asynchronous rendering.</returns>
public static async Task ExecuteAsync([NotNull] IView view,
[NotNull] ActionContext actionContext,
[NotNull] ViewDataDictionary viewData,
[NotNull] ITempDataDictionary tempData,
[NotNull] HtmlHelperOptions htmlHelperOptions,
MediaTypeHeaderValue contentType)
{
var response = actionContext.HttpContext.Response;
contentType = contentType ?? DefaultContentType;
if (contentType.Encoding == null)
{
// Do not modify the user supplied content type, so copy it instead
contentType = contentType.Copy();
contentType.Encoding = Encoding.UTF8;
}
response.ContentType = contentType.ToString();
using (var writer = new HttpResponseStreamWriter(response.Body, contentType.Encoding))
{
var viewContext = new ViewContext(
actionContext,
view,
viewData,
tempData,
writer,
htmlHelperOptions);
await view.RenderAsync(viewContext);
}
}
/// <summary>
/// Gets the content type and encoding that need to be used for the response.
/// The priority for selecting the content type is:
/// 1. ContentType property set on the action result
/// 2. <see cref="HttpResponse.ContentType"/> property set on <see cref="HttpResponse"/>
/// 3. Default content type set on the action result
/// </summary>
/// <remarks>
/// The user supplied content type is not modified and is used as is. For example, if user
/// sets the content type to be "text/plain" without any encoding, then the default content type's
/// encoding is used to write the response and the ContentType header is set to be "text/plain" without any
/// "charset" information.
/// </remarks>
/// <param name="actionResultContentType">ContentType set on the action result</param>
/// <param name="httpResponseContentType"><see cref="HttpResponse.ContentType"/> property set
/// on <see cref="HttpResponse"/></param>
/// <param name="defaultContentType">The default content type of the action result.</param>
/// <param name="resolvedContentType">The content type to be used for the response content type header</param>
/// <param name="resolvedContentTypeEncoding">Encoding to be used for writing the response</param>
public static void ResolveContentTypeAndEncoding(
MediaTypeHeaderValue actionResultContentType,
string httpResponseContentType,
MediaTypeHeaderValue defaultContentType,
out string resolvedContentType,
out Encoding resolvedContentTypeEncoding)
{
Debug.Assert(defaultContentType != null);
Debug.Assert(defaultContentType.Encoding != null);
// 1. User sets the ContentType property on the action result
if (actionResultContentType != null)
{
resolvedContentType = actionResultContentType.ToString();
resolvedContentTypeEncoding = actionResultContentType.Encoding ?? defaultContentType.Encoding;
return;
}
// 2. User sets the ContentType property on the http response directly
if (!string.IsNullOrEmpty(httpResponseContentType))
{
MediaTypeHeaderValue mediaType;
if (MediaTypeHeaderValue.TryParse(httpResponseContentType, out mediaType))
{
resolvedContentType = httpResponseContentType;
resolvedContentTypeEncoding = mediaType.Encoding ?? defaultContentType.Encoding;
}
else
{
resolvedContentType = httpResponseContentType;
resolvedContentTypeEncoding = defaultContentType.Encoding;
}
return;
}
// 3. Fall-back to the default content type
resolvedContentType = defaultContentType.ToString();
resolvedContentTypeEncoding = defaultContentType.Encoding;
}
public async Task Invoke(HttpContext httpContext)
{
// OnStarting handlers have to be set early during request processing,
// even though they are used to create the response.
// ----------------------
// ASP.NET 4 - HttpContext.Response.Headers
// ASP.NET 4 - HttpContext.Response.Cookies
//
// Issue with all response headers is that they will not be sent after anything has been written to the
// response body.
// To solve this, use OnStarting to set a callback that will be called right before headers are sent.
// Set the headers in that callback.
//
// Setting a cookie results in a Set-Cookie response header.
// So use an OnStarting handler here as well.
//>40
httpContext.Response.OnStarting(SetHeaders, state: httpContext);
httpContext.Response.OnStarting(SetCookies, state: httpContext);
//<40
// ==================================================================
// Context
// Unique request ID (no ASP.NET 4 counterpart)
//>01
string requestId = httpContext.TraceIdentifier;
//<01
// ASP.NET 4 - HttpContext.Items
//>01b
IDictionary<object, object> items = httpContext.Items;
//<01b
// ==================================================================
// Request
// ASP.NET 4 - HttpContext.Request.HttpMethod
//>02
string httpMethod = httpContext.Request.Method;
//<02
// ----------
// ASP.NET 4 - HttpContext.Request.QueryString
//>03
IReadableStringCollection queryParameters = httpContext.Request.Query;
// If no query parameter "key" used, values will have 0 items
// If single value used for a key (...?key=v1), values will have 1 item ("v1")
// If key has multiple values (...?key=v1&key=v2), values will have 2 items ("v1" and "v2")
IList<string> values = queryParameters["key"];
// If no query parameter "key" used, value will be ""
// If single value used for a key (...?key=v1), value will be "v1"
// If key has multiple values (...?key=v1&key=v2), value will be "v1,v2"
string value = queryParameters["key"].ToString();
//<03
// ----------
// ASP.NET 4 - HttpContext.Request.Url and HttpContext.Request.RawUrl
//>04
// using Microsoft.AspNet.Http.Extensions;
var url = httpContext.Request.GetDisplayUrl();
//<04
// ASP.NET 4 - HttpContext.Request.IsSecureConnection
//>05
var isSecureConnection = httpContext.Request.IsHttps;
//<05
// ----------
// ASP.NET 4 - HttpContext.Request.UserHostAddress
//>06
var userHostAddress = httpContext.Connection.RemoteIpAddress?.ToString();
//<06
// ----------
// ASP.NET 4 - HttpContext.Request.Cookies
//>07
IReadableStringCollection cookies = httpContext.Request.Cookies;
string unknownCookieValue = cookies["unknownCookie"]; // will be null (no exception)
string knownCookieValue = cookies["cookie1name"]; // will be actual value
//<07
// ----------
// ASP.NET 4 - HttpContext.Request.RequestContext.RouteData
// RouteData is not available in middleware in RC1. See
// https://github.com/aspnet/Mvc/issues/3826
// http://stackoverflow.com/questions/34083240/accessing-requestcontext-routedata-values-in-asp-net-5-vnext
// ----------
// ASP.NET 4 - HttpContext.Request.Headers
//>08
// using Microsoft.AspNet.Http.Headers;
// using Microsoft.Net.Http.Headers;
IHeaderDictionary headersDictionary = httpContext.Request.Headers;
// GetTypedHeaders extension method provides strongly typed access to many headers
var requestHeaders = httpContext.Request.GetTypedHeaders();
CacheControlHeaderValue cacheControlHeaderValue = requestHeaders.CacheControl;
// For unknown header, unknownheaderValues has zero items and unknownheaderValue is ""
IList<string> unknownheaderValues = headersDictionary["unknownheader"];
string unknownheaderValue = headersDictionary["unknownheader"].ToString();
// For known header, knownheaderValues has 1 item and knownheaderValue is the value
IList<string> knownheaderValues = headersDictionary[HeaderNames.AcceptLanguage];
string knownheaderValue = headersDictionary[HeaderNames.AcceptLanguage].ToString();
//<08
// ----------
// ASP.NET 4 - HttpContext.Request.UserAgent
//>12
string userAgent = headersDictionary[HeaderNames.UserAgent].ToString();
//<12
// ASP.NET 4 - HttpContext.Request.UrlReferrer
//>13
string urlReferrer = headersDictionary[HeaderNames.Referer].ToString();
//<13
// ASP.NET 4 - HttpContext.Request.ContentType
//>14
// using Microsoft.Net.Http.Headers;
MediaTypeHeaderValue mediaHeaderValue = requestHeaders.ContentType;
string contentType = mediaHeaderValue?.MediaType; // ex. application/x-www-form-urlencoded
string contentMainType = mediaHeaderValue?.Type; // ex. application
string contentSubType = mediaHeaderValue?.SubType; // ex. x-www-form-urlencoded
System.Text.Encoding requestEncoding = mediaHeaderValue?.Encoding;
//<14
// ----------
// ASP.NET 4 - HttpContext.Request.Form
//>15
if (httpContext.Request.HasFormContentType)
{
IFormCollection form;
form = httpContext.Request.Form; // sync
// Or
form = await httpContext.Request.ReadFormAsync(); // async
string firstName = form["firstname"];
string lastName = form["lastname"];
}
//<15
// ----------
// See
// http://stackoverflow.com/questions/31389781/read-body-twice-in-asp-net-5/
// ASP.NET 4 - HttpContext.Request.InputStream
// Unlike reading the form, reading the raw body is not from a buffer.
// So you can only do this once per request.
//
// If you need to read the body multiple times per request, see
// http://stackoverflow.com/questions/31389781/read-body-twice-in-asp-net-5/
//>16
string inputBody;
using (var reader = new System.IO.StreamReader(
httpContext.Request.Body, System.Text.Encoding.UTF8))
{
inputBody = reader.ReadToEnd();
}
//<16
// Use this middleware as a handler, so no call to
// await _next.Invoke(aspnet5HttpContext);
// ==================================================================
// Response
// ASP.NET 4 - HttpContext.Response.Status
// ASP.NET 4 - HttpContext.Response.StatusDescription (obsolete, removed from HTTP/2)
//>30
// using Microsoft.AspNet.Http;
httpContext.Response.StatusCode = StatusCodes.Status200OK;
//<30
// ASP.NET 4 - HttpContext.Response.ContentEncoding and HttpContext.Response.ContentType
//>31
// using Microsoft.Net.Http.Headers;
var mediaType = new MediaTypeHeaderValue("application/json");
mediaType.Encoding = System.Text.Encoding.UTF8;
httpContext.Response.ContentType = mediaType.ToString();
//<31
// ASP.NET 4 - HttpContext.Response.ContentType only
//>32
httpContext.Response.ContentType = "text/html";
//<32
// ----------------------
// ASP.NET 4 - HttpContext.Response.Output
//
//>33
string responseContent = GetResponseContent();
await httpContext.Response.WriteAsync(responseContent);
//<33
}
private static ActionContext GetActionContext(
MediaTypeHeaderValue contentType,
MemoryStream responseStream = null)
{
var request = new Mock<HttpRequest>();
var headers = new HeaderDictionary();
request.Setup(r => r.ContentType).Returns(contentType.ToString());
request.SetupGet(r => r.Headers).Returns(headers);
headers[HeaderNames.AcceptCharset] = contentType.Charset;
var response = new Mock<HttpResponse>();
response.SetupGet(f => f.Body).Returns(responseStream ?? new MemoryStream());
var httpContext = new Mock<HttpContext>();
httpContext.SetupGet(c => c.Request).Returns(request.Object);
httpContext.SetupGet(c => c.Response).Returns(response.Object);
return new ActionContext(httpContext.Object, routeData: null, actionDescriptor: null);
}
public void ToString_UseDifferentMediaTypes_AllSerializedCorrectly()
{
var mediaType = new MediaTypeHeaderValue("text/plain");
Assert.Equal("text/plain", mediaType.ToString());
mediaType.Charset = "utf-8";
Assert.Equal("text/plain; charset=utf-8", mediaType.ToString());
mediaType.Parameters.Add(new NameValueHeaderValue("custom", "\"custom value\""));
Assert.Equal("text/plain; charset=utf-8; custom=\"custom value\"", mediaType.ToString());
mediaType.Charset = null;
Assert.Equal("text/plain; custom=\"custom value\"", mediaType.ToString());
}
private static MediaTypeHeaderValue Clone(MediaTypeHeaderValue contentType)
{
return MediaTypeHeaderValue.Parse(contentType.ToString());
}
/// <summary>
/// Sets mapping for the format to specified media type.
/// If the format already exists, the media type will be overwritten with the new value.
/// </summary>
/// <param name="format">The format value.</param>
/// <param name="contentType">The media type for the format value.</param>
public void SetMediaTypeMappingForFormat(string format, MediaTypeHeaderValue contentType)
{
if (format == null)
{
throw new ArgumentNullException(nameof(format));
}
if (contentType == null)
{
throw new ArgumentNullException(nameof(contentType));
}
ValidateContentType(contentType);
format = RemovePeriodIfPresent(format);
_map[format] = contentType.ToString();
}
