protected internal NameValueHeaderValue (NameValueHeaderValue source)
{
this.Name = source.Name;
this.Value = source.Value;
}
public static bool TryParse (string input, out NameValueHeaderValue parsedValue)
{
throw new NotImplementedException ();
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request.Headers.Contains("Forwarded"))
{
try {
var header = request.Headers.GetValues("Forwarded").First();
var forwardedHeader = header.Split(';').Where(nv => !string.IsNullOrEmpty(nv)).Select(nv => NameValueHeaderValue.Parse(nv)).ToDictionary(nv => nv.Name, nv => nv.Value);
var gatewayUrl = new Uri(string.Format("{0}://{1}", forwardedHeader["proto"], forwardedHeader["host"]));
request.Properties[ConferenceWebApi.Tools.HttpRequestMessageExtensions.GatewayUrlKey] = gatewayUrl;
} catch (Exception ex)
{
return(Task.FromResult <HttpResponseMessage>(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("Failed to parse Forwarded header : " + ex.Message)
}));
}
}
return(base.SendAsync(request, cancellationToken));
}
/// <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);
}
public void Ctor_NameValidFormat_SuccessfullyCreated()
{
NameValueHeaderValue nameValue = new NameValueHeaderValue("text", null);
Assert.Equal("text", nameValue.Name);
}
public void Value_CallSetterWithInvalidValues_Throw()
{
// Just verify that the setter calls the same validation the ctor invokes.
Assert.Throws <FormatException>(() => { var x = new NameValueHeaderValue("name"); x.Value = " x "; });
Assert.Throws <FormatException>(() => { var x = new NameValueHeaderValue("name"); x.Value = "x y"; });
}
private static void CheckValue(string value)
{
NameValueHeaderValue nameValue = new NameValueHeaderValue("text", value);
Assert.Equal(value, nameValue.Value);
}
private void CheckInvalidParse(string input)
{
Assert.Throws <FormatException>(() => { NameValueHeaderValue.Parse(input); });
}
private void CheckValidParse(string input, NameValueHeaderValue expectedResult)
{
NameValueHeaderValue result = NameValueHeaderValue.Parse(input);
Assert.Equal(expectedResult, result);
}
public void Ctor_NameEmpty_Throw()
{
// null and empty should be treated the same. So we also throw for empty strings.
Assert.Throws <ArgumentException>(() => { NameValueHeaderValue nameValue = new NameValueHeaderValue(string.Empty); });
}
public void Ctor_NameNull_Throw()
{
Assert.Throws <ArgumentException>(() => { NameValueHeaderValue nameValue = new NameValueHeaderValue(null); });
}
