public ContentNegotiationResult(MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType) { if (formatter == null) { throw new ArgumentNullException("formatter"); } this._formatter = formatter; this.MediaType = mediaType; }
public ObjectContent(object value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType) { if (value == null) { throw new ArgumentNullException("value must not be null."); } this.Value = value; this.Formatter = formatter; this.MediaType = mediaType; }
/// <summary> /// Initializes a new instance of the <see cref="MediaTypeFormatterMatch"/> class. /// </summary> /// <param name="formatter">The matching formatter.</param> /// <param name="mediaType">The media type. Can be <c>null</c> in which case the media type <c>application/octet-stream</c> is used.</param> /// <param name="quality">The quality of the match. Can be <c>null</c> in which case it is considered a full match with a value of 1.0</param> /// <param name="ranking">The kind of match.</param> public MediaTypeFormatterMatch(MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType, double? quality, MediaTypeFormatterMatchRanking ranking) { if (formatter == null) { throw Error.ArgumentNull("formatter"); } Formatter = formatter; MediaType = mediaType != null ? mediaType.Clone() : MediaTypeConstants.ApplicationOctetStreamMediaType; Quality = quality ?? FormattingUtilities.Match; Ranking = ranking; }
public ObjectContent(object value, MediaTypeFormatter formatter, string mediaType) : this(value, formatter, BuildHeaderValue(mediaType)) { }
/// <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(HttpRequestMessage request, MediaTypeFormatter formatter) { if (request == null) { throw Error.ArgumentNull("request"); } if (formatter == null) { throw Error.ArgumentNull("formatter"); } // If there are any SupportedEncodings then we pick an encoding if (formatter.SupportedEncodings.Count > 0) { // Sort Accept-Charset header values //IEnumerable<StringWithQualityHeaderValue> sortedAcceptCharsetValues = SortStringWithQualityHeaderValuesByQFactor(request.Headers.AcceptCharset); // TODO: Fix instead of using Formatter.SelectCharacterEncoding(); IEnumerable<StringWithQualityHeaderValue> sortedAcceptCharsetValues = Enumerable.Empty<StringWithQualityHeaderValue>(); // Check for match based on accept-charset headers foreach (StringWithQualityHeaderValue acceptCharset in sortedAcceptCharsetValues) { foreach (Encoding encoding in formatter.SupportedEncodings) { 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 return formatter.SelectCharacterEncoding(request); } return null; }
/// <summary> /// Pick the first supported media type and indicate we've matched only on type /// 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> /// <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) { if (type == null) { throw Error.ArgumentNull("type"); } if (formatter == null) { throw Error.ArgumentNull("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. if (!ExcludeMatchOnTypeOnly) { MediaTypeHeaderValue mediaType = formatter.SupportedMediaTypes.FirstOrDefault(); return new MediaTypeFormatterMatch(formatter, mediaType, FormattingUtilities.Match, MediaTypeFormatterMatchRanking.MatchOnCanWriteType); } 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(HttpRequestMessage request, MediaTypeFormatter formatter) { if (request == null) { throw Error.ArgumentNull("request"); } if (formatter == null) { throw Error.ArgumentNull("formatter"); } MediaTypeHeaderValue requestMediaType = request.ContentType; if (requestMediaType != null) { foreach (MediaTypeHeaderValue supportedMediaType in formatter.SupportedMediaTypes) { if (supportedMediaType != null && supportedMediaType.IsSubsetOf(requestMediaType)) { return new MediaTypeFormatterMatch(formatter, supportedMediaType, FormattingUtilities.Match, MediaTypeFormatterMatchRanking.MatchOnRequestMediaType); } } } 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(HttpRequestMessage request, MediaTypeFormatter formatter) { if (request == null) { throw Error.ArgumentNull("request"); } if (formatter == null) { throw Error.ArgumentNull("formatter"); } foreach (MediaTypeMapping mapping in formatter.MediaTypeMappings) { 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) { foreach (MediaTypeHeaderValue supportedMediaType in formatter.SupportedMediaTypes) { 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; }
public JsonContractResolver(MediaTypeFormatter formatter) { this._formatter = formatter; // Need this setting to have [Serializable] types serialized correctly IgnoreSerializableAttribute = false; }