Extension methods/Object content/Dummy conneg/and formurlformatter
This commit is contained in:
Yishai Galatzer
parent
bd2e434da9
commit
1ba47fa480
|
|
@ -0,0 +1,27 @@
|
|||
using System;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Owin;
|
||||
using System.Net;
|
||||
|
||||
namespace Microsoft.AspNet.Mvc
|
||||
{
|
||||
public class NoContentResult : IActionResult
|
||||
{
|
||||
public async Task ExecuteResultAsync(RequestContext context)
|
||||
{
|
||||
if (context == null)
|
||||
{
|
||||
throw new ArgumentNullException("context");
|
||||
}
|
||||
|
||||
IOwinResponse response = context.HttpContext.Response;
|
||||
|
||||
response.StatusCode = (int)HttpStatusCode.NoContent;
|
||||
|
||||
await Task.FromResult(false);
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
using System;
|
||||
using System.Diagnostics.Contracts;
|
||||
using System.IO;
|
||||
using System.Net.Http;
|
||||
using System.Net.Http.Formatting;
|
||||
using System.Net.Http.Headers;
|
||||
using System.Threading.Tasks;
|
||||
using System.Web.Http;
|
||||
|
||||
namespace Microsoft.AspNet.Mvc
|
||||
{
|
||||
/// <summary>
|
||||
/// Contains a value as well as an associated <see cref="MediaTypeFormatter"/> that will be
|
||||
/// used to serialize the value when writing this content.
|
||||
/// </summary>
|
||||
public class ObjectContent : HttpContent
|
||||
{
|
||||
private object _value;
|
||||
private readonly MediaTypeFormatter _formatter;
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the <see cref="ObjectContent"/> class.
|
||||
/// </summary>
|
||||
/// <param name="type">The type of object this instance will contain.</param>
|
||||
/// <param name="value">The value of the object this instance will contain.</param>
|
||||
/// <param name="formatter">The formatter to use when serializing the value.</param>
|
||||
public ObjectContent(Type type, object value, MediaTypeFormatter formatter)
|
||||
: this(type, value, formatter, (MediaTypeHeaderValue)null)
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the <see cref="ObjectContent"/> class.
|
||||
/// </summary>
|
||||
/// <param name="type">The type of object this instance will contain.</param>
|
||||
/// <param name="value">The value of the object this instance will contain.</param>
|
||||
/// <param name="formatter">The formatter to use when serializing the value.</param>
|
||||
/// <param name="mediaType">The authoritative value of the content's Content-Type header. Can be <c>null</c> in which case the
|
||||
/// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
|
||||
public ObjectContent(Type type, object value, MediaTypeFormatter formatter, string mediaType)
|
||||
: this(type, value, formatter, BuildHeaderValue(mediaType))
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the <see cref="ObjectContent"/> class.
|
||||
/// </summary>
|
||||
/// <param name="type">The type of object this instance will contain.</param>
|
||||
/// <param name="value">The value of the object this instance will contain.</param>
|
||||
/// <param name="formatter">The formatter to use when serializing the value.</param>
|
||||
/// <param name="mediaType">The authoritative value of the content's Content-Type header. Can be <c>null</c> in which case the
|
||||
/// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
|
||||
public ObjectContent(Type type, object value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType)
|
||||
{
|
||||
if (type == null)
|
||||
{
|
||||
throw new ArgumentNullException("type");
|
||||
}
|
||||
if (formatter == null)
|
||||
{
|
||||
throw new ArgumentNullException("formatter");
|
||||
}
|
||||
|
||||
if (!formatter.CanWriteType(type))
|
||||
{
|
||||
throw new ArgumentNullException(formatter.GetType().FullName + " cannot write " + type.Name);
|
||||
}
|
||||
|
||||
_formatter = formatter;
|
||||
ObjectType = type;
|
||||
|
||||
VerifyAndSetObject(value);
|
||||
_formatter.SetDefaultContentHeaders(type, Headers, mediaType);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the type of object managed by this <see cref="ObjectContent"/> instance.
|
||||
/// </summary>
|
||||
public Type ObjectType { get; private set; }
|
||||
|
||||
/// <summary>
|
||||
/// The <see cref="MediaTypeFormatter">formatter</see> associated with this content instance.
|
||||
/// </summary>
|
||||
public MediaTypeFormatter Formatter
|
||||
{
|
||||
get { return _formatter; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets or sets the value of the current <see cref="ObjectContent"/>.
|
||||
/// </summary>
|
||||
public object Value
|
||||
{
|
||||
get { return _value; }
|
||||
set { _value = value; }
|
||||
}
|
||||
|
||||
internal static MediaTypeHeaderValue BuildHeaderValue(string mediaType)
|
||||
{
|
||||
return mediaType != null ? new MediaTypeHeaderValue(mediaType) : null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Asynchronously serializes the object's content to the given <paramref name="stream"/>.
|
||||
/// </summary>
|
||||
/// <param name="stream">The <see cref="Stream"/> to which to write.</param>
|
||||
/// <param name="context">The associated <see cref="TransportContext"/>.</param>
|
||||
/// <returns>A <see cref="Task"/> instance that is asynchronously serializing the object's content.</returns>
|
||||
protected override Task SerializeToStreamAsync(Stream stream, System.Net.TransportContext context)
|
||||
{
|
||||
return _formatter.WriteToStreamAsync(ObjectType, Value, stream, this, context);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Computes the length of the stream if possible.
|
||||
/// </summary>
|
||||
/// <param name="length">The computed length of the stream.</param>
|
||||
/// <returns><c>true</c> if the length has been computed; otherwise <c>false</c>.</returns>
|
||||
protected override bool TryComputeLength(out long length)
|
||||
{
|
||||
length = -1;
|
||||
return false;
|
||||
}
|
||||
|
||||
private static bool IsTypeNullable(Type type)
|
||||
{
|
||||
return !type.IsValueType() ||
|
||||
(type.IsGenericType() &&
|
||||
type.GetGenericTypeDefinition() == typeof(Nullable<>));
|
||||
}
|
||||
|
||||
private void VerifyAndSetObject(object value)
|
||||
{
|
||||
Contract.Assert(ObjectType != null, "Type cannot be null");
|
||||
|
||||
if (value == null)
|
||||
{
|
||||
// Null may not be assigned to value types (unless Nullable<T>)
|
||||
if (!IsTypeNullable(ObjectType))
|
||||
{
|
||||
throw new InvalidOperationException("CannotUseNullValueType " + typeof(ObjectContent).Name + " " + ObjectType.Name);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Non-null objects must be a type assignable to Type
|
||||
Type objectType = value.GetType();
|
||||
if (!ObjectType.IsAssignableFrom(objectType))
|
||||
{
|
||||
throw new ArgumentException("value Resources.ObjectAndTypeDisagree, objectType.Name, ObjectType.Name");
|
||||
}
|
||||
}
|
||||
|
||||
_value = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,599 @@
|
|||
//// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
using Microsoft.Owin;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.ObjectModel;
|
||||
using System.Diagnostics.Contracts;
|
||||
using System.Linq;
|
||||
using System.Net.Http;
|
||||
using System.Net.Http.Formatting;
|
||||
using System.Net.Http.Headers;
|
||||
using System.Text;
|
||||
using System.Web.Http;
|
||||
|
||||
namespace Microsoft.AspNet.Mvc
|
||||
{
|
||||
/// <summary>
|
||||
/// Class that selects a <see cref="MediaTypeFormatter"/> for an <see cref="HttpRequestMessage"/>
|
||||
/// or <see cref="HttpResponseMessage"/>.
|
||||
/// </summary>
|
||||
public class DefaultContentNegotiator : IOwinContentNegotiator
|
||||
{
|
||||
// public DefaultContentNegotiator()
|
||||
// : this(false)
|
||||
// {
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Initializes a new instance of the <see cref="DefaultContentNegotiator"/> with
|
||||
// /// the given setting for <paramref name="excludeMatchOnTypeOnly"/>.
|
||||
// /// </summary>
|
||||
// /// <param name="excludeMatchOnTypeOnly">
|
||||
// /// If ExcludeMatchOnTypeOnly is true then we don't match on type only which means
|
||||
// /// that we return null if we can't match on anything in the request. This is useful
|
||||
// /// for generating 406 (Not Acceptable) status codes.
|
||||
// /// </param>
|
||||
// public DefaultContentNegotiator(bool excludeMatchOnTypeOnly)
|
||||
// {
|
||||
// ExcludeMatchOnTypeOnly = excludeMatchOnTypeOnly;
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// If ExcludeMatchOnTypeOnly is true then we don't match on type only which means
|
||||
// /// that we return null if we can't match on anything in the request. This is useful
|
||||
// /// for generating 406 (Not Acceptable) status codes.
|
||||
// /// </summary>
|
||||
// public bool ExcludeMatchOnTypeOnly { get; private set; }
|
||||
|
||||
// /// <summary>
|
||||
// /// Performs content negotiating by selecting the most appropriate <see cref="MediaTypeFormatter"/> out of the passed in
|
||||
// /// <paramref name="formatters"/> for the given <paramref name="request"/> that can serialize an object of the given
|
||||
// /// <paramref name="type"/>.
|
||||
// /// </summary>
|
||||
// /// <param name="type">The type to be serialized.</param>
|
||||
// /// <param name="request">The request.</param>
|
||||
// /// <param name="formatters">The set of <see cref="MediaTypeFormatter"/> objects from which to choose.</param>
|
||||
// /// <returns>The result of the negotiation containing the most appropriate <see cref="MediaTypeFormatter"/> instance,
|
||||
// /// or <c>null</c> if there is no appropriate formatter.</returns>
|
||||
// public virtual ContentNegotiationResult Negotiate(Type type, IOwinContext context, IEnumerable<MediaTypeFormatter> formatters)
|
||||
// {
|
||||
// // Performance-sensitive
|
||||
// if (type == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("type");
|
||||
// }
|
||||
// if (context == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("context");
|
||||
// }
|
||||
// if (formatters == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("formatters");
|
||||
// }
|
||||
|
||||
// var request = context.Request;
|
||||
|
||||
// // Go through each formatter to compute how well it matches.
|
||||
// Collection<MediaTypeFormatterMatch> matches = ComputeFormatterMatches(type, request, formatters);
|
||||
|
||||
// // Select best formatter match among the matches
|
||||
// MediaTypeFormatterMatch bestFormatterMatch = SelectResponseMediaTypeFormatter(matches);
|
||||
|
||||
// // We found a best formatter
|
||||
// if (bestFormatterMatch != null)
|
||||
// {
|
||||
// // Find the best character encoding for the selected formatter
|
||||
// Encoding bestEncodingMatch = SelectResponseCharacterEncoding(request, bestFormatterMatch.Formatter);
|
||||
// if (bestEncodingMatch != null)
|
||||
// {
|
||||
// bestFormatterMatch.MediaType.CharSet = bestEncodingMatch.WebName;
|
||||
// }
|
||||
|
||||
// MediaTypeHeaderValue bestMediaType = bestFormatterMatch.MediaType;
|
||||
// MediaTypeFormatter bestFormatter = bestFormatterMatch.Formatter; // this is OData only scenario at the moment: .GetPerRequestFormatterInstance(type, request, bestMediaType);
|
||||
// return new ContentNegotiationResult(bestFormatter, bestMediaType);
|
||||
// }
|
||||
|
||||
// return null;
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Determine how well each formatter matches by associating a <see cref="MediaTypeFormatterMatchRanking"/> value
|
||||
// /// with the formatter. Then associate the quality of the match based on q-factors and other parameters. The result of this
|
||||
// /// method is a collection of the matches found categorized and assigned a quality value.
|
||||
// /// </summary>
|
||||
// /// <param name="type">The type to be serialized.</param>
|
||||
// /// <param name="request">The request.</param>
|
||||
// /// <param name="formatters">The set of <see cref="MediaTypeFormatter"/> objects from which to choose.</param>
|
||||
// /// <returns>A collection containing all the matches.</returns>
|
||||
// protected virtual Collection<MediaTypeFormatterMatch> ComputeFormatterMatches(Type type, IOwinRequest request, IEnumerable<MediaTypeFormatter> formatters)
|
||||
// {
|
||||
// // Performance-sensitive
|
||||
// if (type == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("type");
|
||||
// }
|
||||
// if (request == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("request");
|
||||
// }
|
||||
// if (formatters == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("formatters");
|
||||
// }
|
||||
|
||||
// IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptValues = null;
|
||||
|
||||
// // Go through each formatter to find how well it matches.
|
||||
// List<MediaTypeFormatterMatch> matches = new List<MediaTypeFormatterMatch>();
|
||||
// MediaTypeFormatter[] writingFormatters = GetWritingFormatters(formatters);
|
||||
// for (int i = 0; i < writingFormatters.Length; i++)
|
||||
// {
|
||||
// MediaTypeFormatter formatter = writingFormatters[i];
|
||||
// MediaTypeFormatterMatch match = null;
|
||||
|
||||
// // Check first that formatter can write the actual type
|
||||
// if (!formatter.CanWriteType(type))
|
||||
// {
|
||||
// // Formatter can't even write the type so no match at all
|
||||
// continue;
|
||||
// }
|
||||
|
||||
// // Match against media type mapping.
|
||||
// if ((match = MatchMediaTypeMapping(request, formatter)) != null)
|
||||
// {
|
||||
// matches.Add(match);
|
||||
// continue;
|
||||
// }
|
||||
|
||||
// // Match against the accept header values.
|
||||
// if (sortedAcceptValues == null)
|
||||
// {
|
||||
// // Sort the Accept header values in descending order based on q-factor
|
||||
// sortedAcceptValues = SortMediaTypeWithQualityHeaderValuesByQFactor(request.Headers.Accept);
|
||||
// }
|
||||
// if ((match = MatchAcceptHeader(sortedAcceptValues, formatter)) != null)
|
||||
// {
|
||||
// matches.Add(match);
|
||||
// continue;
|
||||
// }
|
||||
|
||||
// // Match against request's media type if any
|
||||
// if ((match = MatchRequestMediaType(request, formatter)) != null)
|
||||
// {
|
||||
// matches.Add(match);
|
||||
// continue;
|
||||
// }
|
||||
|
||||
// // Check whether we should match on type or stop the matching process.
|
||||
// // The latter is used to generate 406 (Not Acceptable) status codes.
|
||||
// bool shouldMatchOnType = ShouldMatchOnType(sortedAcceptValues);
|
||||
|
||||
// // Match against the type of object we are writing out
|
||||
// if (shouldMatchOnType && (match = MatchType(type, formatter)) != null)
|
||||
// {
|
||||
// matches.Add(match);
|
||||
// continue;
|
||||
// }
|
||||
// }
|
||||
|
||||
// return matches;
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Select the best match among the candidate matches found.
|
||||
// /// </summary>
|
||||
// /// <param name="matches">The collection of matches.</param>
|
||||
// /// <returns>The <see cref="MediaTypeFormatterMatch"/> determined to be the best match.</returns>
|
||||
// protected virtual MediaTypeFormatterMatch SelectResponseMediaTypeFormatter(ICollection<MediaTypeFormatterMatch> matches)
|
||||
// {
|
||||
// // Performance-sensitive
|
||||
// if (matches == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("matches");
|
||||
// }
|
||||
|
||||
// List<MediaTypeFormatterMatch> matchList = matches.AsList();
|
||||
|
||||
// MediaTypeFormatterMatch bestMatchOnType = null;
|
||||
// MediaTypeFormatterMatch bestMatchOnAcceptHeaderLiteral = null;
|
||||
// MediaTypeFormatterMatch bestMatchOnAcceptHeaderSubtypeMediaRange = null;
|
||||
// MediaTypeFormatterMatch bestMatchOnAcceptHeaderAllMediaRange = null;
|
||||
// MediaTypeFormatterMatch bestMatchOnMediaTypeMapping = null;
|
||||
// MediaTypeFormatterMatch bestMatchOnRequestMediaType = null;
|
||||
|
||||
// // Go through each formatter to find the best match in each category.
|
||||
// for (int i = 0; i < matchList.Count; i++)
|
||||
// {
|
||||
// MediaTypeFormatterMatch match = matchList[i];
|
||||
// switch (match.Ranking)
|
||||
// {
|
||||
// case MediaTypeFormatterMatchRanking.MatchOnCanWriteType:
|
||||
// // First match by type trumps all other type matches
|
||||
// if (bestMatchOnType == null)
|
||||
// {
|
||||
// bestMatchOnType = match;
|
||||
// }
|
||||
// break;
|
||||
|
||||
// case MediaTypeFormatterMatchRanking.MatchOnRequestWithMediaTypeMapping:
|
||||
// // Matches on accept headers using mappings must choose the highest quality match
|
||||
// bestMatchOnMediaTypeMapping = UpdateBestMatch(bestMatchOnMediaTypeMapping, match);
|
||||
// break;
|
||||
|
||||
// case MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral:
|
||||
// // Matches on accept headers must choose the highest quality match.
|
||||
// // A match of 0.0 means we won't use it at all.
|
||||
// bestMatchOnAcceptHeaderLiteral = UpdateBestMatch(bestMatchOnAcceptHeaderLiteral, match);
|
||||
// break;
|
||||
|
||||
// case MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange:
|
||||
// // Matches on accept headers must choose the highest quality match.
|
||||
// // A match of 0.0 means we won't use it at all.
|
||||
// bestMatchOnAcceptHeaderSubtypeMediaRange = UpdateBestMatch(bestMatchOnAcceptHeaderSubtypeMediaRange, match);
|
||||
// break;
|
||||
|
||||
// case MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange:
|
||||
// // Matches on accept headers must choose the highest quality match.
|
||||
// // A match of 0.0 means we won't use it at all.
|
||||
// bestMatchOnAcceptHeaderAllMediaRange = UpdateBestMatch(bestMatchOnAcceptHeaderAllMediaRange, match);
|
||||
// break;
|
||||
|
||||
// case MediaTypeFormatterMatchRanking.MatchOnRequestMediaType:
|
||||
// // First match on request content type trumps other request content matches
|
||||
// if (bestMatchOnRequestMediaType == null)
|
||||
// {
|
||||
// bestMatchOnRequestMediaType = match;
|
||||
// }
|
||||
// break;
|
||||
// }
|
||||
// }
|
||||
|
||||
// // If we received matches based on both supported media types and from media type mappings,
|
||||
// // we want to give precedence to the media type mappings, but only if their quality is >= that of the supported media type.
|
||||
// // We do this because media type mappings are the user's extensibility point and must take precedence over normal
|
||||
// // supported media types in the case of a tie. The 99% case is where both have quality 1.0.
|
||||
// if (bestMatchOnMediaTypeMapping != null)
|
||||
// {
|
||||
// MediaTypeFormatterMatch mappingOverride = bestMatchOnMediaTypeMapping;
|
||||
// mappingOverride = UpdateBestMatch(mappingOverride, bestMatchOnAcceptHeaderLiteral);
|
||||
// mappingOverride = UpdateBestMatch(mappingOverride, bestMatchOnAcceptHeaderSubtypeMediaRange);
|
||||
// mappingOverride = UpdateBestMatch(mappingOverride, bestMatchOnAcceptHeaderAllMediaRange);
|
||||
// if (mappingOverride != bestMatchOnMediaTypeMapping)
|
||||
// {
|
||||
// bestMatchOnMediaTypeMapping = null;
|
||||
// }
|
||||
// }
|
||||
|
||||
// // now select the formatter and media type
|
||||
// // A MediaTypeMapping is highest precedence -- it is an extensibility point
|
||||
// // allowing the user to override normal accept header matching
|
||||
// MediaTypeFormatterMatch bestMatch = null;
|
||||
// if (bestMatchOnMediaTypeMapping != null)
|
||||
// {
|
||||
// bestMatch = bestMatchOnMediaTypeMapping;
|
||||
// }
|
||||
// else if (bestMatchOnAcceptHeaderLiteral != null ||
|
||||
// bestMatchOnAcceptHeaderSubtypeMediaRange != null ||
|
||||
// bestMatchOnAcceptHeaderAllMediaRange != null)
|
||||
// {
|
||||
// bestMatch = UpdateBestMatch(bestMatch, bestMatchOnAcceptHeaderLiteral);
|
||||
// bestMatch = UpdateBestMatch(bestMatch, bestMatchOnAcceptHeaderSubtypeMediaRange);
|
||||
// bestMatch = UpdateBestMatch(bestMatch, bestMatchOnAcceptHeaderAllMediaRange);
|
||||
// }
|
||||
// else if (bestMatchOnRequestMediaType != null)
|
||||
// {
|
||||
// bestMatch = bestMatchOnRequestMediaType;
|
||||
// }
|
||||
// else if (bestMatchOnType != null)
|
||||
// {
|
||||
// bestMatch = bestMatchOnType;
|
||||
// }
|
||||
|
||||
// return bestMatch;
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Determine the best character encoding for writing the response. First we look
|
||||
// /// for accept-charset headers and if not found then we try to match
|
||||
// /// any charset encoding in the request (in case of PUT, POST, etc.)
|
||||
// /// If no encoding is found then we use the default for the formatter.
|
||||
// /// </summary>
|
||||
// /// <returns>The <see cref="Encoding"/> determined to be the best match.</returns>
|
||||
// protected virtual Encoding SelectResponseCharacterEncoding(IOwinRequest request, MediaTypeFormatter formatter)
|
||||
// {
|
||||
// if (request == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("request");
|
||||
// }
|
||||
// if (formatter == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("formatter");
|
||||
// }
|
||||
|
||||
// // If there are any SupportedEncodings then we pick an encoding
|
||||
// List<Encoding> supportedEncodings = formatter.SupportedEncodingsInternal;
|
||||
// if (supportedEncodings.Count > 0)
|
||||
// {
|
||||
// // Sort Accept-Charset header values
|
||||
// IEnumerable<StringWithQualityHeaderValue> sortedAcceptCharsetValues = SortStringWithQualityHeaderValuesByQFactor(request.Headers.AcceptCharset);
|
||||
|
||||
// // Check for match based on accept-charset headers
|
||||
// foreach (StringWithQualityHeaderValue acceptCharset in sortedAcceptCharsetValues)
|
||||
// {
|
||||
// for (int i = 0; i < supportedEncodings.Count; i++)
|
||||
// {
|
||||
// Encoding encoding = supportedEncodings[i];
|
||||
// if (encoding != null && acceptCharset.Quality != FormattingUtilities.NoMatch &&
|
||||
// (acceptCharset.Value.Equals(encoding.WebName, StringComparison.OrdinalIgnoreCase) ||
|
||||
// acceptCharset.Value.Equals("*", StringComparison.OrdinalIgnoreCase)))
|
||||
// {
|
||||
// return encoding;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
// // Check for match based on any request entity body
|
||||
|
||||
// // TODO: Transform to use request content headers directly
|
||||
// // was - request.Content != null ? request.Content.Headers : null
|
||||
// return formatter.SelectCharacterEncoding(null);
|
||||
// }
|
||||
|
||||
// return null;
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Match a request against the <see cref="MediaTypeMapping"/>s registered with the formatter.
|
||||
// /// </summary>
|
||||
// /// <param name="request">The request to match.</param>
|
||||
// /// <param name="formatter">The formatter to match against.</param>
|
||||
// /// <returns>A <see cref="MediaTypeFormatterMatch"/> indicating the quality of the match or null is no match.</returns>
|
||||
// protected virtual MediaTypeFormatterMatch MatchMediaTypeMapping(IOwinRequest request, MediaTypeFormatter formatter)
|
||||
// {
|
||||
// if (request == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("request");
|
||||
// }
|
||||
// if (formatter == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("formatter");
|
||||
// }
|
||||
|
||||
// List<MediaTypeMapping> mediaTypeMappings = formatter.MediaTypeMappingsInternal;
|
||||
// for (int i = 0; i < mediaTypeMappings.Count; i++)
|
||||
// {
|
||||
// MediaTypeMapping mapping = mediaTypeMappings[i];
|
||||
// double quality;
|
||||
// if (mapping != null && ((quality = mapping.TryMatchMediaType(request)) > FormattingUtilities.NoMatch))
|
||||
// {
|
||||
// return new MediaTypeFormatterMatch(formatter, mapping.MediaType, quality, MediaTypeFormatterMatchRanking.MatchOnRequestWithMediaTypeMapping);
|
||||
// }
|
||||
// }
|
||||
|
||||
// return null;
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Match the request accept header field values against the formatter's registered supported media types.
|
||||
// /// </summary>
|
||||
// /// <param name="sortedAcceptValues">The sorted accept header values to match.</param>
|
||||
// /// <param name="formatter">The formatter to match against.</param>
|
||||
// /// <returns>A <see cref="MediaTypeFormatterMatch"/> indicating the quality of the match or null is no match.</returns>
|
||||
// protected virtual MediaTypeFormatterMatch MatchAcceptHeader(IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptValues, MediaTypeFormatter formatter)
|
||||
// {
|
||||
// if (sortedAcceptValues == null)
|
||||
// {
|
||||
// throw Error.ArgumentNull("sortedAcceptValues");
|
||||
// }
|
||||
// if (formatter == null)
|
||||
// {
|
||||
// throw Error.ArgumentNull("formatter");
|
||||
// }
|
||||
|
||||
// foreach (MediaTypeWithQualityHeaderValue acceptMediaTypeValue in sortedAcceptValues)
|
||||
// {
|
||||
// List<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypesInternal;
|
||||
// for (int i = 0; i < supportedMediaTypes.Count; i++)
|
||||
// {
|
||||
// MediaTypeHeaderValue supportedMediaType = supportedMediaTypes[i];
|
||||
// MediaTypeHeaderValueRange range;
|
||||
// if (supportedMediaType != null && acceptMediaTypeValue.Quality != FormattingUtilities.NoMatch &&
|
||||
// supportedMediaType.IsSubsetOf(acceptMediaTypeValue, out range))
|
||||
// {
|
||||
// MediaTypeFormatterMatchRanking ranking;
|
||||
// switch (range)
|
||||
// {
|
||||
// case MediaTypeHeaderValueRange.AllMediaRange:
|
||||
// ranking = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange;
|
||||
// break;
|
||||
|
||||
// case MediaTypeHeaderValueRange.SubtypeMediaRange:
|
||||
// ranking = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange;
|
||||
// break;
|
||||
|
||||
// default:
|
||||
// ranking = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral;
|
||||
// break;
|
||||
// }
|
||||
|
||||
// return new MediaTypeFormatterMatch(formatter, supportedMediaType, acceptMediaTypeValue.Quality, ranking);
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
// return null;
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Match any request media type (in case there is a request entity body) against the formatter's registered
|
||||
// /// media types.
|
||||
// /// </summary>
|
||||
// /// <param name="request">The request to match.</param>
|
||||
// /// <param name="formatter">The formatter to match against.</param>
|
||||
// /// <returns>A <see cref="MediaTypeFormatterMatch"/> indicating the quality of the match or null is no match.</returns>
|
||||
// protected virtual MediaTypeFormatterMatch MatchRequestMediaType(IOwinRequest request, MediaTypeFormatter formatter)
|
||||
// {
|
||||
// if (request == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("request");
|
||||
// }
|
||||
// if (formatter == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("formatter");
|
||||
// }
|
||||
|
||||
// if (request.Content != null)
|
||||
// {
|
||||
// MediaTypeHeaderValue requestMediaType = request.Content.Headers.ContentType;
|
||||
// if (requestMediaType != null)
|
||||
// {
|
||||
// List<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypesInternal;
|
||||
// for (int i = 0; i < supportedMediaTypes.Count; i++)
|
||||
// {
|
||||
// MediaTypeHeaderValue supportedMediaType = supportedMediaTypes[i];
|
||||
// if (supportedMediaType != null && supportedMediaType.IsSubsetOf(requestMediaType))
|
||||
// {
|
||||
// return new MediaTypeFormatterMatch(formatter, supportedMediaType, FormattingUtilities.Match, MediaTypeFormatterMatchRanking.MatchOnRequestMediaType);
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
// return null;
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Determine whether to match on type or not. This is used to determine whether to
|
||||
// /// generate a 406 response or use the default media type formatter in case there
|
||||
// /// is no match against anything in the request. If ExcludeMatchOnTypeOnly is true
|
||||
// /// then we don't match on type unless there are no accept headers.
|
||||
// /// </summary>
|
||||
// /// <param name="sortedAcceptValues">The sorted accept header values to match.</param>
|
||||
// /// <returns>True if not ExcludeMatchOnTypeOnly and accept headers with a q-factor bigger than 0.0 are present.</returns>
|
||||
// protected virtual bool ShouldMatchOnType(IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptValues)
|
||||
// {
|
||||
// if (sortedAcceptValues == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("sortedAcceptValues");
|
||||
// }
|
||||
|
||||
// return !(ExcludeMatchOnTypeOnly && sortedAcceptValues.Any());
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Pick the first supported media type and indicate we've matched only on type
|
||||
// /// </summary>
|
||||
// /// <param name="type">The type to be serialized.</param>
|
||||
// /// <param name="formatter">The formatter we are matching against.</param>
|
||||
// /// <returns>A <see cref="MediaTypeFormatterMatch"/> indicating the quality of the match or null is no match.</returns>
|
||||
// protected virtual MediaTypeFormatterMatch MatchType(Type type, MediaTypeFormatter formatter)
|
||||
// {
|
||||
// // Performance-sensitive
|
||||
// if (type == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("type");
|
||||
// }
|
||||
// if (formatter == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("formatter");
|
||||
// }
|
||||
|
||||
// // We already know that we do match on type -- otherwise we wouldn't even be called --
|
||||
// // so this is just a matter of determining how we match.
|
||||
// MediaTypeHeaderValue mediaType = null;
|
||||
// List<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypesInternal;
|
||||
// if (supportedMediaTypes.Count > 0)
|
||||
// {
|
||||
// mediaType = supportedMediaTypes[0];
|
||||
// }
|
||||
// return new MediaTypeFormatterMatch(formatter, mediaType, FormattingUtilities.Match, MediaTypeFormatterMatchRanking.MatchOnCanWriteType);
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Sort Accept header values and related header field values with similar syntax rules
|
||||
// /// (if more than 1) in descending order based on q-factor.
|
||||
// /// </summary>
|
||||
// /// <param name="headerValues">The header values to sort.</param>
|
||||
// /// <returns>The sorted header values.</returns>
|
||||
// protected virtual IEnumerable<MediaTypeWithQualityHeaderValue> SortMediaTypeWithQualityHeaderValuesByQFactor(ICollection<MediaTypeWithQualityHeaderValue> headerValues)
|
||||
// {
|
||||
// if (headerValues == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("headerValues");
|
||||
// }
|
||||
|
||||
// if (headerValues.Count > 1)
|
||||
// {
|
||||
// // Use OrderBy() instead of Array.Sort() as it performs fewer comparisons. In this case the comparisons
|
||||
// // are quite expensive so OrderBy() performs better.
|
||||
// return headerValues.OrderByDescending(m => m, MediaTypeWithQualityHeaderValueComparer.QualityComparer).ToArray();
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// return headerValues;
|
||||
// }
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Sort Accept-Charset, Accept-Encoding, Accept-Language and related header field values with similar syntax rules
|
||||
// /// (if more than 1) in descending order based on q-factor.
|
||||
// /// </summary>
|
||||
// /// <param name="headerValues">The header values to sort.</param>
|
||||
// /// <returns>The sorted header values.</returns>
|
||||
// protected virtual IEnumerable<StringWithQualityHeaderValue> SortStringWithQualityHeaderValuesByQFactor(ICollection<StringWithQualityHeaderValue> headerValues)
|
||||
// {
|
||||
// if (headerValues == null)
|
||||
// {
|
||||
// throw new ArgumentNullException("headerValues");
|
||||
// }
|
||||
|
||||
// if (headerValues.Count > 1)
|
||||
// {
|
||||
// // Use OrderBy() instead of Array.Sort() as it performs fewer comparisons. In this case the comparisons
|
||||
// // are quite expensive so OrderBy() performs better.
|
||||
// return headerValues.OrderByDescending(m => m, StringWithQualityHeaderValueComparer.QualityComparer).ToArray();
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// return headerValues;
|
||||
// }
|
||||
// }
|
||||
|
||||
// /// <summary>
|
||||
// /// Evaluates whether a match is better than the current match and if so returns the replacement; otherwise returns the
|
||||
// /// current match.
|
||||
// /// </summary>
|
||||
// protected virtual MediaTypeFormatterMatch UpdateBestMatch(MediaTypeFormatterMatch current, MediaTypeFormatterMatch potentialReplacement)
|
||||
// {
|
||||
// if (potentialReplacement == null)
|
||||
// {
|
||||
// return current;
|
||||
// }
|
||||
|
||||
// if (current != null)
|
||||
// {
|
||||
// return (potentialReplacement.Quality > current.Quality) ? potentialReplacement : current;
|
||||
// }
|
||||
|
||||
// return potentialReplacement;
|
||||
// }
|
||||
|
||||
// private static MediaTypeFormatter[] GetWritingFormatters(IEnumerable<MediaTypeFormatter> formatters)
|
||||
// {
|
||||
// Contract.Assert(formatters != null);
|
||||
// MediaTypeFormatterCollection formatterCollection = formatters as MediaTypeFormatterCollection;
|
||||
// if (formatterCollection != null)
|
||||
// {
|
||||
// return formatterCollection.WritingFormatters;
|
||||
// }
|
||||
// return formatters.AsArray();
|
||||
// }
|
||||
|
||||
public ContentNegotiationResult Negotiate(Type type, IOwinContext context, IEnumerable<MediaTypeFormatter> formatters)
|
||||
{
|
||||
return new ContentNegotiationResult(formatters.First(), formatters.First().SupportedMediaTypes.First());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
using System.Diagnostics.Contracts;
|
||||
using System.Linq;
|
||||
|
||||
namespace System.Collections.Generic
|
||||
{
|
||||
internal static class IEnumerableExtensions
|
||||
{
|
||||
public static T[] AsArray<T>(this IEnumerable<T> values)
|
||||
{
|
||||
Contract.Assert(values != null);
|
||||
|
||||
T[] array = values as T[];
|
||||
if (array == null)
|
||||
{
|
||||
array = values.ToArray();
|
||||
}
|
||||
return array;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Reflection;
|
||||
|
||||
namespace Microsoft.AspNet.Mvc
|
||||
{
|
||||
internal static class TypeExtensions
|
||||
{
|
||||
#if NETFX_CORE
|
||||
private static bool EqualTo(this Type[] t1, Type[] t2)
|
||||
{
|
||||
if (t1.Length != t2.Length)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
for (int idx = 0; idx < t1.Length; ++idx)
|
||||
{
|
||||
if (t1[idx] != t2[idx])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public static ConstructorInfo GetConstructor(this Type type, Type[] types)
|
||||
{
|
||||
return type.GetTypeInfo().DeclaredConstructors
|
||||
.Where(c => c.IsPublic)
|
||||
.SingleOrDefault(c => c.GetParameters()
|
||||
.Select(p => p.ParameterType).ToArray().EqualTo(types));
|
||||
}
|
||||
#endif
|
||||
|
||||
public static Type ExtractGenericInterface(this Type queryType, Type interfaceType)
|
||||
{
|
||||
Func<Type, bool> matchesInterface = t => t.IsGenericType() && t.GetGenericTypeDefinition() == interfaceType;
|
||||
return (matchesInterface(queryType)) ? queryType : queryType.GetInterfaces().FirstOrDefault(matchesInterface);
|
||||
}
|
||||
|
||||
#if NETFX_CORE
|
||||
public static Type[] GetGenericArguments(this Type type)
|
||||
{
|
||||
return type.GetTypeInfo().GenericTypeArguments;
|
||||
}
|
||||
|
||||
public static Type[] GetInterfaces(this Type type)
|
||||
{
|
||||
return type.GetTypeInfo().ImplementedInterfaces.ToArray();
|
||||
}
|
||||
#endif
|
||||
|
||||
#if NETFX_CORE
|
||||
public static bool IsAssignableFrom(this Type type, Type c)
|
||||
{
|
||||
return type.GetTypeInfo().IsAssignableFrom(c.GetTypeInfo());
|
||||
}
|
||||
#endif
|
||||
|
||||
public static bool IsGenericType(this Type type)
|
||||
{
|
||||
#if NETFX_CORE
|
||||
return type.GetTypeInfo().IsGenericType;
|
||||
#else
|
||||
return type.IsGenericType;
|
||||
#endif
|
||||
}
|
||||
|
||||
public static bool IsInterface(this Type type)
|
||||
{
|
||||
#if NETFX_CORE
|
||||
return type.GetTypeInfo().IsInterface;
|
||||
#else
|
||||
return type.IsInterface;
|
||||
#endif
|
||||
}
|
||||
|
||||
public static bool IsValueType(this Type type)
|
||||
{
|
||||
#if NETFX_CORE
|
||||
return type.GetTypeInfo().IsValueType;
|
||||
#else
|
||||
return type.IsValueType;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Net.Http;
|
||||
using System.Net.Http.Formatting;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace Microsoft.AspNet.Mvc
|
||||
{
|
||||
// Supports JQuery schema on FormURL.
|
||||
public class JQueryMvcFormUrlEncodedFormatter : FormUrlEncodedMediaTypeFormatter
|
||||
{
|
||||
public override bool CanReadType(Type type)
|
||||
{
|
||||
if (type == null)
|
||||
{
|
||||
throw new ArgumentNullException("type");
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
|
||||
{
|
||||
if (type == null)
|
||||
{
|
||||
throw new ArgumentNullException("type");
|
||||
}
|
||||
|
||||
if (readStream == null)
|
||||
{
|
||||
throw new ArgumentNullException("readStream");
|
||||
}
|
||||
|
||||
// For simple types, defer to base class
|
||||
if (base.CanReadType(type))
|
||||
{
|
||||
return base.ReadFromStreamAsync(type, readStream, content, formatterLogger);
|
||||
}
|
||||
|
||||
return ReadFromStreamAsyncCore(type, readStream, content, formatterLogger);
|
||||
}
|
||||
|
||||
private async Task<object> ReadFromStreamAsyncCore(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
|
||||
{
|
||||
object obj = await base.ReadFromStreamAsync(typeof(FormDataCollection), readStream, content, formatterLogger);
|
||||
FormDataCollection fd = (FormDataCollection)obj;
|
||||
|
||||
try
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
//return fd.ReadAs(type, String.Empty, RequiredMemberSelector, formatterLogger);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
if (formatterLogger == null)
|
||||
{
|
||||
throw;
|
||||
}
|
||||
formatterLogger.LogError(String.Empty, e);
|
||||
return GetDefaultValueForType(type);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,238 @@
|
|||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
using System.Net.Http.Formatting;
|
||||
using System.Net.Http.Headers;
|
||||
using System.Runtime.Serialization;
|
||||
using Newtonsoft.Json.Linq;
|
||||
using System;
|
||||
using System.Net.Http;
|
||||
|
||||
namespace Microsoft.AspNet.Mvc
|
||||
{
|
||||
/// <summary>
|
||||
/// Provides various internal utility functions
|
||||
/// </summary>
|
||||
internal static class FormattingUtilities
|
||||
{
|
||||
// Supported date formats for input.
|
||||
private static readonly string[] dateFormats = new string[]
|
||||
{
|
||||
// "r", // RFC 1123, required output format but too strict for input
|
||||
"ddd, d MMM yyyy H:m:s 'GMT'", // RFC 1123 (r, except it allows both 1 and 01 for date and time)
|
||||
"ddd, d MMM yyyy H:m:s", // RFC 1123, no zone - assume GMT
|
||||
"d MMM yyyy H:m:s 'GMT'", // RFC 1123, no day-of-week
|
||||
"d MMM yyyy H:m:s", // RFC 1123, no day-of-week, no zone
|
||||
"ddd, d MMM yy H:m:s 'GMT'", // RFC 1123, short year
|
||||
"ddd, d MMM yy H:m:s", // RFC 1123, short year, no zone
|
||||
"d MMM yy H:m:s 'GMT'", // RFC 1123, no day-of-week, short year
|
||||
"d MMM yy H:m:s", // RFC 1123, no day-of-week, short year, no zone
|
||||
|
||||
"dddd, d'-'MMM'-'yy H:m:s 'GMT'", // RFC 850
|
||||
"dddd, d'-'MMM'-'yy H:m:s", // RFC 850 no zone
|
||||
"ddd MMM d H:m:s yyyy", // ANSI C's asctime() format
|
||||
|
||||
"ddd, d MMM yyyy H:m:s zzz", // RFC 5322
|
||||
"ddd, d MMM yyyy H:m:s", // RFC 5322 no zone
|
||||
"d MMM yyyy H:m:s zzz", // RFC 5322 no day-of-week
|
||||
"d MMM yyyy H:m:s", // RFC 5322 no day-of-week, no zone
|
||||
};
|
||||
|
||||
// Valid header token characters are within the range 0x20 < c < 0x7F excluding the following characters
|
||||
private const string NonTokenChars = "()<>@,;:\\\"/[]?={}";
|
||||
|
||||
/// <summary>
|
||||
/// Quality factor to indicate a perfect match.
|
||||
/// </summary>
|
||||
public const double Match = 1.0;
|
||||
|
||||
/// <summary>
|
||||
/// Quality factor to indicate no match.
|
||||
/// </summary>
|
||||
public const double NoMatch = 0.0;
|
||||
|
||||
/// <summary>
|
||||
/// The default max depth for our formatter is 256
|
||||
/// </summary>
|
||||
public const int DefaultMaxDepth = 256;
|
||||
|
||||
/// <summary>
|
||||
/// The default min depth for our formatter is 1
|
||||
/// </summary>
|
||||
public const int DefaultMinDepth = 1;
|
||||
|
||||
/// <summary>
|
||||
/// HTTP X-Requested-With header field name
|
||||
/// </summary>
|
||||
public const string HttpRequestedWithHeader = @"x-requested-with";
|
||||
|
||||
/// <summary>
|
||||
/// HTTP X-Requested-With header field value
|
||||
/// </summary>
|
||||
public const string HttpRequestedWithHeaderValue = @"XMLHttpRequest";
|
||||
|
||||
/// <summary>
|
||||
/// HTTP Host header field name
|
||||
/// </summary>
|
||||
public const string HttpHostHeader = "Host";
|
||||
|
||||
/// <summary>
|
||||
/// HTTP Version token
|
||||
/// </summary>
|
||||
public const string HttpVersionToken = "HTTP";
|
||||
|
||||
///// <summary>
|
||||
///// A <see cref="Type"/> representing <see cref="HttpRequestMessage"/>.
|
||||
///// </summary>
|
||||
//public static readonly Type HttpRequestMessageType = typeof(HttpRequestMessage);
|
||||
|
||||
///// <summary>
|
||||
///// A <see cref="Type"/> representing <see cref="HttpResponseMessage"/>.
|
||||
///// </summary>
|
||||
//public static readonly Type HttpResponseMessageType = typeof(HttpResponseMessage);
|
||||
|
||||
///// <summary>
|
||||
///// A <see cref="Type"/> representing <see cref="HttpContent"/>.
|
||||
///// </summary>
|
||||
//public static readonly Type HttpContentType = typeof(HttpContent);
|
||||
|
||||
/// <summary>
|
||||
/// A <see cref="Type"/> representing <see cref="DelegatingEnumerable{T}"/>.
|
||||
/// </summary>
|
||||
public static readonly Type DelegatingEnumerableGenericType = typeof(DelegatingEnumerable<>);
|
||||
|
||||
/// <summary>
|
||||
/// A <see cref="Type"/> representing <see cref="IEnumerable{T}"/>.
|
||||
/// </summary>
|
||||
public static readonly Type EnumerableInterfaceGenericType = typeof(IEnumerable<>);
|
||||
|
||||
/// <summary>
|
||||
/// A <see cref="Type"/> representing <see cref="IQueryable{T}"/>.
|
||||
/// </summary>
|
||||
public static readonly Type QueryableInterfaceGenericType = typeof(IQueryable<>);
|
||||
|
||||
/// <summary>
|
||||
/// Determines whether <paramref name="type"/> is a <see cref="JToken"/> type.
|
||||
/// </summary>
|
||||
/// <param name="type">The type to test.</param>
|
||||
/// <returns>
|
||||
/// <c>true</c> if <paramref name="type"/> is a <see cref="JToken"/> type; otherwise, <c>false</c>.
|
||||
/// </returns>
|
||||
public static bool IsJTokenType(Type type)
|
||||
{
|
||||
return typeof(JToken).IsAssignableFrom(type);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates an empty <see cref="HttpContentHeaders"/> instance. The only way is to get it from a dummy
|
||||
/// <see cref="HttpContent"/> instance.
|
||||
/// </summary>
|
||||
/// <returns>The created instance.</returns>
|
||||
public static HttpContentHeaders CreateEmptyContentHeaders()
|
||||
{
|
||||
HttpContent tempContent = null;
|
||||
HttpContentHeaders contentHeaders = null;
|
||||
try
|
||||
{
|
||||
tempContent = new StringContent(String.Empty);
|
||||
contentHeaders = tempContent.Headers;
|
||||
contentHeaders.Clear();
|
||||
}
|
||||
finally
|
||||
{
|
||||
// We can dispose the content without touching the headers
|
||||
if (tempContent != null)
|
||||
{
|
||||
tempContent.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
return contentHeaders;
|
||||
}
|
||||
|
||||
//#if NETFX_CORE // MaxDepth is a DOS mitigation. We don't support MaxDepth in portable libraries because it is strictly client side.
|
||||
|
||||
// /// <summary>
|
||||
// /// Create a default reader quotas with a default depth quota of 1K
|
||||
// /// </summary>
|
||||
// /// <returns></returns>
|
||||
// public static XmlDictionaryReaderQuotas CreateDefaultReaderQuotas()
|
||||
// {
|
||||
// return XmlDictionaryReaderQuotas.Max;
|
||||
//#else
|
||||
// return new XmlDictionaryReaderQuotas()
|
||||
// {
|
||||
// MaxArrayLength = Int32.MaxValue,
|
||||
// MaxBytesPerRead = Int32.MaxValue,
|
||||
// MaxDepth = DefaultMaxDepth,
|
||||
// MaxNameTableCharCount = Int32.MaxValue,
|
||||
// MaxStringContentLength = Int32.MaxValue
|
||||
// };
|
||||
//#endif
|
||||
// }
|
||||
|
||||
/// <summary>
|
||||
/// Remove bounding quotes on a token if present
|
||||
/// </summary>
|
||||
/// <param name="token">Token to unquote.</param>
|
||||
/// <returns>Unquoted token.</returns>
|
||||
public static string UnquoteToken(string token)
|
||||
{
|
||||
if (String.IsNullOrWhiteSpace(token))
|
||||
{
|
||||
return token;
|
||||
}
|
||||
|
||||
if (token.StartsWith("\"", StringComparison.Ordinal) && token.EndsWith("\"", StringComparison.Ordinal) && token.Length > 1)
|
||||
{
|
||||
return token.Substring(1, token.Length - 2);
|
||||
}
|
||||
|
||||
return token;
|
||||
}
|
||||
|
||||
public static bool ValidateHeaderToken(string token)
|
||||
{
|
||||
if (token == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
foreach (char c in token)
|
||||
{
|
||||
if (c < 0x21 || c > 0x7E || NonTokenChars.IndexOf(c) != -1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public static string DateToString(DateTimeOffset dateTime)
|
||||
{
|
||||
// Format according to RFC1123; 'r' uses invariant info (DateTimeFormatInfo.InvariantInfo)
|
||||
return dateTime.ToUniversalTime().ToString("r", CultureInfo.InvariantCulture);
|
||||
}
|
||||
|
||||
public static bool TryParseDate(string input, out DateTimeOffset result)
|
||||
{
|
||||
return DateTimeOffset.TryParseExact(input, dateFormats, DateTimeFormatInfo.InvariantInfo,
|
||||
DateTimeStyles.AllowWhiteSpaces | DateTimeStyles.AssumeUniversal,
|
||||
out result);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Parses valid integer strings with no leading signs, whitespace or other <see cref="NumberStyles"/>
|
||||
/// </summary>
|
||||
/// <param name="value">The value to parse</param>
|
||||
/// <param name="result">The result</param>
|
||||
/// <returns>True if value was valid; false otherwise.</returns>
|
||||
public static bool TryParseInt32(string value, out int result)
|
||||
{
|
||||
return Int32.TryParse(value, NumberStyles.None, NumberFormatInfo.InvariantInfo, out result);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
using Microsoft.Owin;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Net.Http.Formatting;
|
||||
|
||||
namespace Microsoft.AspNet.Mvc
|
||||
{
|
||||
public interface IOwinContentNegotiator
|
||||
{
|
||||
ContentNegotiationResult Negotiate(Type type, IOwinContext context, IEnumerable<MediaTypeFormatter> formatters);
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue