コード例 #1
0
        public void TypesEqual_DifferentType_False()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("application/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));

            Assert.False(parsedMediaType1.TypesEqual(ref parsedMediaType2));
        }
コード例 #2
0
        public void SubTypesEqual_SameType_True()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("application/xml"));

            Assert.True(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
        }
コード例 #3
0
        public void TypesEqual_SameType_True()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/json"));

            Assert.True(parsedMediaType1.TypesEqual(ref parsedMediaType2));
        }
コード例 #4
0
        public void SubTypesEqual_DifferentTypeSameLength_False()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/yml"));

            Assert.False(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
        }
コード例 #5
0
        public void QualityFactor_Returns_Q_Value_For_MediaTypeWithQualityHeaderValue()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeWithQualityHeaderValue("text/*", 0.5);
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.Equal(0.5, parsedMediaType.QualityFactor);

            mediaType       = new MediaTypeWithQualityHeaderValue("*/*", 0.0);
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(0.0, parsedMediaType.QualityFactor);

            mediaType       = new MediaTypeWithQualityHeaderValue("application/xml", 1.0);
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType       = new MediaTypeWithQualityHeaderValue("application/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
            mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(0.5, parsedMediaType.QualityFactor);

            MediaTypeWithQualityHeaderValue mediaTypeWithQuality = new MediaTypeWithQualityHeaderValue("application/xml");

            mediaTypeWithQuality.Quality = 0.2;
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeWithQuality);
            Assert.Equal(0.2, parsedMediaType.QualityFactor);
        }
コード例 #6
0
        public void IsSubTypeMediaRange_ReturnsTrueForSubTypeMediaRanges(string mediaType)
        {
            MediaTypeHeaderValue       mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
            ParsedMediaTypeHeaderValue parsedMediaType      = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);

            Assert.True(parsedMediaType.IsSubtypeMediaRange);
        }
コード例 #7
0
        public void IsAllMediaRange_ReturnsFalseForNonFullMediaTypeRanges(string mediaType)
        {
            MediaTypeHeaderValue       mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
            ParsedMediaTypeHeaderValue parsedMediaType      = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);

            Assert.False(parsedMediaType.IsAllMediaRange);
        }
コード例 #8
0
        public void SubTypesEqual_SameTypeDifferentCase_True()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/XML"));

            Assert.True(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
        }
コード例 #9
0
        /// <summary>
        /// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
        /// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
        /// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>. 
        /// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present 
        /// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
        /// parameters.
        /// </summary>
        /// <param name="mediaType1">The first media type.</param>
        /// <param name="mediaType2">The second media type.</param>
        /// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
        /// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
        public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
        {
            // Performance-sensitive
            Contract.Assert(mediaType1 != null);

            if (mediaType2 == null)
            {
                mediaType2Range = MediaTypeHeaderValueRange.None;
                return false;
            }

            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
            mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
                parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
                MediaTypeHeaderValueRange.None;

            if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
                {
                    return false;
                }
            }
            else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
                {
                    return false;
                }
            }

            // So far we either have a full match or a subset match. Now check that all of 
            // mediaType1's parameters are present and equal in mediatype2
            // Optimize for the common case where the parameters inherit from Collection<T> and cache the count which is faster for Collection<T>.
            Collection<NameValueHeaderValue> parameters1 = mediaType1.Parameters.AsCollection();
            int parameterCount1 = parameters1.Count;
            Collection<NameValueHeaderValue> parameters2 = mediaType2.Parameters.AsCollection(); 
            int parameterCount2 = parameters2.Count;
            for (int i = 0; i < parameterCount1; i++)
            {
                NameValueHeaderValue parameter1 = parameters1[i];
                bool found = false;
                for (int j = 0; j < parameterCount2; j++)
                {
                    NameValueHeaderValue parameter2 = parameters2[j];
                    if (parameter1.Equals(parameter2))
                    {
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    return false;
                }
            }
            return true;
        }
コード例 #10
0
 public bool TypesEqual(ref ParsedMediaTypeHeaderValue other)
 {
     if (_delimiterIndex != other._delimiterIndex)
     {
         return false;
     }
     return String.Compare(_mediaType, 0, other._mediaType, 0, _delimiterIndex, StringComparison.OrdinalIgnoreCase) == 0;
 }
コード例 #11
0
        public void SubType_ReturnsJustTheSubType(string mediaType)
        {
            MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
            string subtype = mediaTypeHeaderValue.MediaType.Split('/')[1];
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);

            Assert.Equal(subtype, parsedMediaType.Subtype);
        }
コード例 #12
0
        public void Type_ReturnsJustTheType(string mediaType)
        {
            MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
            string type = mediaTypeHeaderValue.MediaType.Split('/')[0];
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);

            Assert.Equal(type, parsedMediaType.Type);
        }
コード例 #13
0
 public bool TypesEqual(ref ParsedMediaTypeHeaderValue other)
 {
     if (_delimiterIndex != other._delimiterIndex)
     {
         return(false);
     }
     return(String.Compare(_mediaType, 0, other._mediaType, 0, _delimiterIndex, StringComparison.OrdinalIgnoreCase) == 0);
 }
コード例 #14
0
 public bool SubTypesEqual(ref ParsedMediaTypeHeaderValue other)
 {
     int _subTypeLength = _mediaType.Length - _delimiterIndex - 1;
     if (_subTypeLength != other._mediaType.Length - other._delimiterIndex - 1)
     {
         return false;
     }
     return String.Compare(_mediaType, _delimiterIndex + 1, other._mediaType, other._delimiterIndex + 1, _subTypeLength, StringComparison.OrdinalIgnoreCase) == 0;
 }
コード例 #15
0
        public bool SubTypesEqual(ref ParsedMediaTypeHeaderValue other)
        {
            int _subTypeLength = _mediaType.Length - _delimiterIndex - 1;

            if (_subTypeLength != other._mediaType.Length - other._delimiterIndex - 1)
            {
                return(false);
            }
            return(String.Compare(_mediaType, _delimiterIndex + 1, other._mediaType, other._delimiterIndex + 1, _subTypeLength, StringComparison.OrdinalIgnoreCase) == 0);
        }
        public void IsSubTypeMediaRange_Returns_True_For_Media_Ranges()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.True(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");

            mediaType = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.True(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");
        }
コード例 #17
0
        public void IsSubTypeMediaRange_Returns_True_For_Media_Ranges()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.True(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");

            mediaType       = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.True(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");
        }
コード例 #18
0
        /// <summary>
        /// Compares two <see cref="MediaTypeWithQualityHeaderValue"/> based on their quality value (a.k.a their "q-value").
        /// Values with identical q-values are considered equal (i.e the result is 0) with the exception that sub-type wild-cards are
        /// considered less than specific media types and full wild-cards are considered less than sub-type wild-cards. This allows to
        /// sort a sequence of <see cref="StringWithQualityHeaderValue"/> following their q-values in the order of specific media types,
        /// sub-type wildcards, and last any full wild-cards.
        /// </summary>
        /// <param name="mediaType1">The first <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
        /// <param name="mediaType2">The second <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
        /// <returns></returns>
        public int Compare(MediaTypeWithQualityHeaderValue mediaType1, MediaTypeWithQualityHeaderValue mediaType2)
        {
            Contract.Assert(mediaType1 != null, "The 'mediaType1' parameter should not be null.");
            Contract.Assert(mediaType2 != null, "The 'mediaType2' parameter should not be null.");

            if (Object.ReferenceEquals(mediaType1, mediaType2))
            {
                return(0);
            }

            int returnValue = CompareBasedOnQualityFactor(mediaType1, mediaType2);

            if (returnValue == 0)
            {
                ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
                ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);

                if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
                {
                    if (parsedMediaType1.IsAllMediaRange)
                    {
                        return(-1);
                    }
                    else if (parsedMediaType2.IsAllMediaRange)
                    {
                        return(1);
                    }
                    else if (parsedMediaType1.IsSubtypeMediaRange && !parsedMediaType2.IsSubtypeMediaRange)
                    {
                        return(-1);
                    }
                    else if (!parsedMediaType1.IsSubtypeMediaRange && parsedMediaType2.IsSubtypeMediaRange)
                    {
                        return(1);
                    }
                }
                else if (!String.Equals(parsedMediaType1.Subtype, parsedMediaType2.Subtype, StringComparison.OrdinalIgnoreCase))
                {
                    if (parsedMediaType1.IsSubtypeMediaRange)
                    {
                        return(-1);
                    }
                    else if (parsedMediaType2.IsSubtypeMediaRange)
                    {
                        return(1);
                    }
                }
            }

            return(returnValue);
        }
コード例 #19
0
        /// <summary>
        /// Compares two <see cref="MediaTypeWithQualityHeaderValue"/> based on their quality value (a.k.a their
        /// "q-value"). Values with identical q-values are considered equal (i.e the result is 0) with the exception
        /// that sub-type wild-cards are considered less than specific media types and full wild-cards are considered
        /// less than sub-type wild-cards. This allows to sort a sequence of <see cref="StringWithQualityHeaderValue"/>
        /// following their q-values in the order of specific media types, subtype wild-cards, and last any full
        /// wild-cards.
        /// </summary>
        /// <param name="mediaType1">The first <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
        /// <param name="mediaType2">The second <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
        /// <returns>
        /// <c>0</c> if <paramref name="mediaType1"/> and <paramref name="mediaType2"/> are considered equal.
        /// <c>1</c> if <paramref name="mediaType1"/> is considered greater than <paramref name="mediaType2"/>.
        /// <c>-1</c> otherwise (<paramref name="mediaType1"/> is considered less than <paramref name="mediaType2"/>).
        /// </returns>
        public int Compare(MediaTypeWithQualityHeaderValue mediaType1, MediaTypeWithQualityHeaderValue mediaType2)
        {
            Debug.Assert(mediaType1 != null, "The 'mediaType1' parameter should not be null.");
            Debug.Assert(mediaType2 != null, "The 'mediaType2' parameter should not be null.");

            if (ReferenceEquals(mediaType1, mediaType2))
            {
                return(0);
            }

            var returnValue = CompareBasedOnQualityFactor(mediaType1, mediaType2);

            if (returnValue == 0)
            {
                var parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
                var parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);

                if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
                {
                    if (parsedMediaType1.IsAllMediaRange)
                    {
                        return(-1);
                    }
                    else if (parsedMediaType2.IsAllMediaRange)
                    {
                        return(1);
                    }
                    else if (parsedMediaType1.IsSubtypeMediaRange && !parsedMediaType2.IsSubtypeMediaRange)
                    {
                        return(-1);
                    }
                    else if (!parsedMediaType1.IsSubtypeMediaRange && parsedMediaType2.IsSubtypeMediaRange)
                    {
                        return(1);
                    }
                }
                else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
                {
                    if (parsedMediaType1.IsSubtypeMediaRange)
                    {
                        return(-1);
                    }
                    else if (parsedMediaType2.IsSubtypeMediaRange)
                    {
                        return(1);
                    }
                }
            }

            return(returnValue);
        }
コード例 #20
0
            private static void ValidateMediaType(MediaTypeHeaderValue item)
            {
                if (item == null)
                {
                    throw Error.ArgumentNull("item");
                }

                ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(item);

                if (parsedMediaType.IsAllMediaRange || parsedMediaType.IsSubtypeMediaRange)
                {
                    throw Error.Argument("item", Properties.Resources.CannotUseMediaRangeForSupportedMediaType, _mediaTypeHeaderValueType.Name, item.MediaType);
                }
            }
        public void SubType_Returns_Just_The_Sub_Type()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/xml");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal("xml", parsedMediaType.SubType);

            mediaType = new MediaTypeHeaderValue("text/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal("*", parsedMediaType.SubType);

            mediaType = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal("*", parsedMediaType.SubType);
        }
        public void IsAllMediaRange_Returns_True_Only_When_Type_And_SubType_Are_Wildcards()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.False(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");

            mediaType = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.True(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned true.");

            mediaType = new MediaTypeHeaderValue("*/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.False(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");
        }
コード例 #23
0
        public bool TypesEqual(ref ParsedMediaTypeHeaderValue other)
        {
            if (_delimiterIndex != other._delimiterIndex)
            {
                return(false);
            }

            return(string.Compare(
                       strA: _mediaType,
                       indexA: 0,
                       strB: other._mediaType,
                       indexB: 0,
                       length: _delimiterIndex,
                       comparisonType: StringComparison.OrdinalIgnoreCase) == 0);
        }
コード例 #24
0
        public bool TypesEqual(ref ParsedMediaTypeHeaderValue other)
        {
            if (_delimiterIndex != other._delimiterIndex)
            {
                return false;
            }

            return string.Compare(
                strA: _mediaType,
                indexA: 0,
                strB: other._mediaType,
                indexB: 0,
                length: _delimiterIndex,
                comparisonType: StringComparison.OrdinalIgnoreCase) == 0;
        }
コード例 #25
0
        public void IsAllMediaRange_Returns_True_Only_When_Type_And_SubType_Are_Wildcards()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.False(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");

            mediaType       = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.True(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned true.");

            mediaType       = new MediaTypeHeaderValue("*/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.False(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");
        }
コード例 #26
0
        public void SubType_Returns_Just_The_Sub_Type()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("text/xml");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.Equal("xml", parsedMediaType.SubType);

            mediaType       = new MediaTypeHeaderValue("text/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal("*", parsedMediaType.SubType);

            mediaType       = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal("*", parsedMediaType.SubType);
        }
コード例 #27
0
        public bool SubTypesEqual(ref ParsedMediaTypeHeaderValue other)
        {
            var _subTypeLength = _mediaType.Length - _delimiterIndex - 1;
            if (_subTypeLength != other._mediaType.Length - other._delimiterIndex - 1)
            {
                return false;
            }

            return string.Compare(
                strA: _mediaType,
                indexA: _delimiterIndex + 1,
                strB: other._mediaType,
                indexB: other._delimiterIndex + 1,
                length: _subTypeLength,
                comparisonType: StringComparison.OrdinalIgnoreCase) == 0;
        }
コード例 #28
0
            private static void ValidateMediaType(MediaTypeHeaderValue item)
            {
                if (item == null)
                {
                    throw new ArgumentNullException("item");
                }

                ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(item);

                if (parsedMediaType.IsAllMediaRange || parsedMediaType.IsSubTypeMediaRange)
                {
                    throw new ArgumentException(
                              RS.Format(Properties.Resources.CannotUseMediaRangeForSupportedMediaType, _mediaTypeHeaderValueType.Name, item.MediaType),
                              "item");
                }
            }
コード例 #29
0
        public bool SubTypesEqual(ref ParsedMediaTypeHeaderValue other)
        {
            var _subTypeLength = _mediaType.Length - _delimiterIndex - 1;

            if (_subTypeLength != other._mediaType.Length - other._delimiterIndex - 1)
            {
                return(false);
            }

            return(string.Compare(
                       strA: _mediaType,
                       indexA: _delimiterIndex + 1,
                       strB: other._mediaType,
                       indexB: other._delimiterIndex + 1,
                       length: _subTypeLength,
                       comparisonType: StringComparison.OrdinalIgnoreCase) == 0);
        }
        private static int CompareBasedOnQualityFactor(ParsedMediaTypeHeaderValue parsedMediaType1, ParsedMediaTypeHeaderValue parsedMediaType2)
        {
            Contract.Assert(parsedMediaType1 != null, "The 'parsedMediaType1' parameter should not be null.");
            Contract.Assert(parsedMediaType2 != null, "The 'parsedMediaType2' parameter should not be null.");

            double qualityDifference = parsedMediaType1.QualityFactor - parsedMediaType2.QualityFactor;

            if (qualityDifference < 0)
            {
                return(-1);
            }
            else if (qualityDifference > 0)
            {
                return(1);
            }

            return(0);
        }
コード例 #31
0
        /// <summary>
        /// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
        /// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
        /// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
        /// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
        /// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
        /// parameters.
        /// </summary>
        /// <param name="mediaType1">The first media type.</param>
        /// <param name="mediaType2">The second media type.</param>
        /// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
        /// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
        public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
        {
            Contract.Assert(mediaType1 != null);

            if (mediaType2 == null)
            {
                mediaType2Range = MediaTypeHeaderValueRange.None;
                return(false);
            }

            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);

            mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
                              parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
                              MediaTypeHeaderValueRange.None;

            if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
                {
                    return(false);
                }
            }
            else if (!String.Equals(parsedMediaType1.Subtype, parsedMediaType2.Subtype, StringComparison.OrdinalIgnoreCase))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
                {
                    return(false);
                }
            }

            // So far we either have a full match or a subset match. Now check that all of
            // mediaType1's parameters are present and equal in mediatype2
            foreach (NameValueHeaderValue parameter1 in mediaType1.Parameters)
            {
                if (!mediaType2.Parameters.Any(parameter2 => parameter1.Equals(parameter2)))
                {
                    return(false);
                }
            }

            return(true);
        }
コード例 #32
0
        /// <summary>
        /// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
        /// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
        /// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>. 
        /// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present 
        /// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
        /// parameters.
        /// </summary>
        /// <param name="mediaType1">The first media type.</param>
        /// <param name="mediaType2">The second media type.</param>
        /// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
        /// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
        public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
        {
            Contract.Assert(mediaType1 != null);

            if (mediaType2 == null)
            {
                mediaType2Range = MediaTypeHeaderValueRange.None;
                return false;
            }

            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
            mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
                parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
                MediaTypeHeaderValueRange.None;

            if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
                {
                    return false;
                }
            }
            else if (!String.Equals(parsedMediaType1.Subtype, parsedMediaType2.Subtype, StringComparison.OrdinalIgnoreCase))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
                {
                    return false;
                }
            }

            // So far we either have a full match or a subset match. Now check that all of 
            // mediaType1's parameters are present and equal in mediatype2
            foreach (NameValueHeaderValue parameter1 in mediaType1.Parameters)
            {
                if (!mediaType2.Parameters.Any(parameter2 => parameter1.Equals(parameter2)))
                {
                    return false;
                }
            }

            return true;
        }
コード例 #33
0
        public void QualityFactor_Returns_1_For_MediaTypeHeaderValue()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType       = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType       = new MediaTypeHeaderValue("application/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType = new MediaTypeHeaderValue("application/xml");
            mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);
        }
コード例 #34
0
        public void CharSet_Is_CharSet_Of_MediaTypeHeaderValue()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("application/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.Null(parsedMediaType.CharSet);

            mediaType         = new MediaTypeHeaderValue("application/*");
            mediaType.CharSet = "";
            parsedMediaType   = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Null(parsedMediaType.CharSet);

            mediaType         = new MediaTypeHeaderValue("application/xml");
            mediaType.CharSet = "someCharSet";
            parsedMediaType   = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal("someCharSet", parsedMediaType.CharSet);

            mediaType         = new MediaTypeHeaderValue("text/xml");
            mediaType.CharSet = "someCharSet";
            parsedMediaType   = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal("someCharSet", parsedMediaType.CharSet);
        }
コード例 #35
0
        public static bool IsWithinMediaRange(this MediaTypeHeaderValue mediaType, MediaTypeHeaderValue mediaRange)
        {
            Contract.Assert(mediaType != null, "The 'mediaType' parameter should not be null.");
            Contract.Assert(mediaRange != null, "The 'mediaRange' parameter should not be null.");

            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            ParsedMediaTypeHeaderValue parsedMediaRange = new ParsedMediaTypeHeaderValue(mediaRange);

            if (!String.Equals(parsedMediaType.Type, parsedMediaRange.Type, StringComparison.OrdinalIgnoreCase))
            {
                return parsedMediaRange.IsAllMediaRange;
            }
            else if (!String.Equals(parsedMediaType.SubType, parsedMediaRange.SubType, StringComparison.OrdinalIgnoreCase))
            {
                return parsedMediaRange.IsSubTypeMediaRange;
            }

            if (!String.IsNullOrWhiteSpace(parsedMediaRange.CharSet))
            {
                return String.Equals(parsedMediaRange.CharSet, parsedMediaType.CharSet, StringComparison.OrdinalIgnoreCase);
            }

            return true;
        }
コード例 #36
0
        public static bool IsWithinMediaRange(this MediaTypeHeaderValue mediaType, MediaTypeHeaderValue mediaRange)
        {
            Contract.Assert(mediaType != null, "The 'mediaType' parameter should not be null.");
            Contract.Assert(mediaRange != null, "The 'mediaRange' parameter should not be null.");

            ParsedMediaTypeHeaderValue parsedMediaType  = new ParsedMediaTypeHeaderValue(mediaType);
            ParsedMediaTypeHeaderValue parsedMediaRange = new ParsedMediaTypeHeaderValue(mediaRange);

            if (!String.Equals(parsedMediaType.Type, parsedMediaRange.Type, StringComparison.OrdinalIgnoreCase))
            {
                return(parsedMediaRange.IsAllMediaRange);
            }
            else if (!String.Equals(parsedMediaType.SubType, parsedMediaRange.SubType, StringComparison.OrdinalIgnoreCase))
            {
                return(parsedMediaRange.IsSubTypeMediaRange);
            }

            if (!String.IsNullOrWhiteSpace(parsedMediaRange.CharSet))
            {
                return(String.Equals(parsedMediaRange.CharSet, parsedMediaType.CharSet, StringComparison.OrdinalIgnoreCase));
            }

            return(true);
        }
コード例 #37
0
        /// <summary>
        /// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
        /// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
        /// <paramref name="mediaType1"/> is a strict subset of the values and parameters of
        /// <paramref name="mediaType2"/>.
        /// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
        /// and match those of <paramref name="mediaType2"/> then it is a match even though
        /// <paramref name="mediaType2"/> may have additional parameters.
        /// </summary>
        /// <param name="mediaType1">The first media type.</param>
        /// <param name="mediaType2">The second media type.</param>
        /// <param name="mediaType2Range">
        /// Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full
        /// media range.
        /// </param>
        /// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
        public static bool IsSubsetOf(
            this MediaTypeHeaderValue mediaType1,
            MediaTypeHeaderValue mediaType2,
            out MediaTypeFormatterMatchRanking mediaType2Range)
        {
            // Performance-sensitive
            Debug.Assert(mediaType1 != null);

            if (mediaType2 == null)
            {
                mediaType2Range = MediaTypeFormatterMatchRanking.None;
                return false;
            }

            var parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
            var parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
            mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange :
                parsedMediaType2.IsSubtypeMediaRange ? MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange :
                MediaTypeFormatterMatchRanking.None;

            if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
            {
                if (mediaType2Range != MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange)
                {
                    return false;
                }
            }
            else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
            {
                if (mediaType2Range != MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange)
                {
                    return false;
                }
            }
            else
            {
                mediaType2Range = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral;
            }

            // So far we either have a full match or a subset match. Now check that all of
            // mediaType1's parameters are present and equal in mediatype2
            // Optimize for the common case where the parameters inherit from Collection<T> and cache the count which
            // is faster for Collection<T>.
            var parameters1 = mediaType1.Parameters.AsCollection();
            var parameterCount1 = parameters1.Count;
            var parameters2 = mediaType2.Parameters.AsCollection();
            var parameterCount2 = parameters2.Count;
            for (var i = 0; i < parameterCount1; i++)
            {
                var parameter1 = parameters1[i];
                var found = false;
                for (var j = 0; j < parameterCount2; j++)
                {
                    var parameter2 = parameters2[j];
                    if (parameter1.Equals(parameter2))
                    {
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    return false;
                }
            }
            return true;
        }
コード例 #38
0
        /// <summary>
        /// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
        /// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
        /// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
        /// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
        /// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
        /// parameters.
        /// </summary>
        /// <param name="mediaType1">The first media type.</param>
        /// <param name="mediaType2">The second media type.</param>
        /// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
        /// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
        public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
        {
            // Performance-sensitive
            Contract.Assert(mediaType1 != null);

            if (mediaType2 == null)
            {
                mediaType2Range = MediaTypeHeaderValueRange.None;
                return(false);
            }

            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);

            mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
                              parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
                              MediaTypeHeaderValueRange.None;

            if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
                {
                    return(false);
                }
            }
            else if (!String.Equals(parsedMediaType1.Subtype, parsedMediaType2.Subtype, StringComparison.OrdinalIgnoreCase))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
                {
                    return(false);
                }
            }

            // So far we either have a full match or a subset match. Now check that all of
            // mediaType1's parameters are present and equal in mediatype2
            // Optimize for the common case where the parameters inherit from Collection<T> and cache the count which is faster for Collection<T>.
            Collection <NameValueHeaderValue> parameters1 = mediaType1.Parameters.AsCollection();
            int parameterCount1 = parameters1.Count;
            Collection <NameValueHeaderValue> parameters2 = mediaType2.Parameters.AsCollection();
            int parameterCount2 = parameters2.Count;

            for (int i = 0; i < parameterCount1; i++)
            {
                NameValueHeaderValue parameter1 = parameters1[i];
                bool found = false;
                for (int j = 0; j < parameterCount2; j++)
                {
                    NameValueHeaderValue parameter2 = parameters2[j];
                    if (parameter1.Equals(parameter2))
                    {
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    return(false);
                }
            }
            return(true);
        }
        public void QualityFactor_Returns_Q_Value_For_MediaTypeWithQualityHeaderValue()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeWithQualityHeaderValue("text/*", 0.5);
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(0.5, parsedMediaType.QualityFactor);

            mediaType = new MediaTypeWithQualityHeaderValue("*/*", 0.0);
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(0.0, parsedMediaType.QualityFactor);

            mediaType = new MediaTypeWithQualityHeaderValue("application/xml", 1.0);
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
            mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(0.5, parsedMediaType.QualityFactor);

            MediaTypeWithQualityHeaderValue mediaTypeWithQuality = new MediaTypeWithQualityHeaderValue("application/xml");
            mediaTypeWithQuality.Quality = 0.2;
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeWithQuality);
            Assert.Equal(0.2, parsedMediaType.QualityFactor);
        }
        public void CharSet_Is_CharSet_Of_MediaTypeHeaderValue()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Null(parsedMediaType.CharSet);

            mediaType = new MediaTypeHeaderValue("application/*");
            mediaType.CharSet = "";
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Null(parsedMediaType.CharSet);

            mediaType = new MediaTypeHeaderValue("application/xml");
            mediaType.CharSet = "someCharSet";
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal("someCharSet", parsedMediaType.CharSet);

            mediaType = new MediaTypeHeaderValue("text/xml");
            mediaType.CharSet = "someCharSet";
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal("someCharSet", parsedMediaType.CharSet);
        }
        public void QualityFactor_Returns_1_For_MediaTypeHeaderValue()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType = new MediaTypeHeaderValue("application/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);

            mediaType = new MediaTypeHeaderValue("application/xml");
            mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.Equal(1.0, parsedMediaType.QualityFactor);
        }
コード例 #42
0
        /// <summary>
        /// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
        /// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
        /// <paramref name="mediaType1"/> is a strict subset of the values and parameters of
        /// <paramref name="mediaType2"/>.
        /// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
        /// and match those of <paramref name="mediaType2"/> then it is a match even though
        /// <paramref name="mediaType2"/> may have additional parameters.
        /// </summary>
        /// <param name="mediaType1">The first media type.</param>
        /// <param name="mediaType2">The second media type.</param>
        /// <param name="mediaType2Range">
        /// Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full
        /// media range.
        /// </param>
        /// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
        public static bool IsSubsetOf(
            this MediaTypeHeaderValue mediaType1,
            MediaTypeHeaderValue mediaType2,
            out MediaTypeFormatterMatchRanking mediaType2Range)
        {
            // Performance-sensitive
            Debug.Assert(mediaType1 != null);

            if (mediaType2 == null)
            {
                mediaType2Range = MediaTypeFormatterMatchRanking.None;
                return(false);
            }

            var parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
            var parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);

            mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange :
                              parsedMediaType2.IsSubtypeMediaRange ? MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange :
                              MediaTypeFormatterMatchRanking.None;

            if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
            {
                if (mediaType2Range != MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange)
                {
                    return(false);
                }
            }
            else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
            {
                if (mediaType2Range != MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange)
                {
                    return(false);
                }
            }
            else
            {
                mediaType2Range = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral;
            }

            // So far we either have a full match or a subset match. Now check that all of
            // mediaType1's parameters are present and equal in mediatype2
            // Optimize for the common case where the parameters inherit from Collection<T> and cache the count which
            // is faster for Collection<T>.
            var parameters1     = mediaType1.Parameters.AsCollection();
            var parameterCount1 = parameters1.Count;
            var parameters2     = mediaType2.Parameters.AsCollection();
            var parameterCount2 = parameters2.Count;

            for (var i = 0; i < parameterCount1; i++)
            {
                var parameter1 = parameters1[i];
                var found      = false;
                for (var j = 0; j < parameterCount2; j++)
                {
                    var parameter2 = parameters2[j];
                    if (parameter1.Equals(parameter2))
                    {
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    return(false);
                }
            }
            return(true);
        }