public void SelectResponseCharacterEncoding_SelectsEncoding(string[] acceptCharsetHeaders, string requestEncoding, string[] supportedEncodings, string expectedEncoding)
{
// Arrange
MockContentNegotiator negotiator = new MockContentNegotiator();
HttpRequestMessage request = new HttpRequestMessage();
foreach (string acceptCharsetHeader in acceptCharsetHeaders)
{
request.Headers.AcceptCharset.Add(StringWithQualityHeaderValue.Parse(acceptCharsetHeader));
}
if (requestEncoding != null)
{
Encoding reqEncoding = Encoding.GetEncoding(requestEncoding);
StringContent content = new StringContent("", reqEncoding, "text/plain");
request.Content = content;
}
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter()
{
CallBase = true
};
foreach (string supportedEncoding in supportedEncodings)
{
formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding));
}
// Act
Encoding actualEncoding = negotiator.SelectResponseCharacterEncoding(request, formatter);
// Assert
if (expectedEncoding == null)
{
Assert.Null(actualEncoding);
}
else
{
Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding);
}
}
public void Parse_Invalid()
{
try {
StringWithQualityHeaderValue.Parse(null);
Assert.Fail("#1");
} catch (FormatException) {
}
try {
StringWithQualityHeaderValue.Parse(" ");
Assert.Fail("#2");
} catch (FormatException) {
}
try {
StringWithQualityHeaderValue.Parse("a,b");
Assert.Fail("#3");
} catch (FormatException) {
}
}
private static HttpRequestMessage PrepareSimpleGetRequest()
{
// Most relevant GET request headers considered simple:
// * Accept
// * Accept-Language
// See also https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
var request = new HttpRequestMessage(HttpMethod.Get, "/");
var acceptedMediaType = MediaTypeWithQualityHeaderValue.Parse("text/plain");
request.Headers.Accept.Add(acceptedMediaType);
var acceptedLanguage = StringWithQualityHeaderValue.Parse("en-us");
request.Headers.AcceptLanguage.Add(acceptedLanguage);
return(request);
}
private async Task <List <Enemy> > RequestEnemiesAsync()
{
var client = new HttpClient();
var queryString = HttpUtility.ParseQueryString(string.Empty);
// Request headers
client.DefaultRequestHeaders.AcceptLanguage.Add(StringWithQualityHeaderValue.Parse("en"));
client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", "fb4676955bae402fb50b49909808f425");
var uri = "https://www.haloapi.com/metadata/h5/metadata/enemies?" + queryString;
var response = await client.GetAsync(uri);
response.EnsureSuccessStatusCode();
var jsonResult = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <Enemy[]>(jsonResult);
return(result.ToList());
}
public SearchClient(ILoggerFactory loggerFactory)
{
this.logger = loggerFactory.CreateLogger(nameof(SearchClient)) ?? throw new ArgumentNullException(nameof(loggerFactory));
var handlerWithDecompression = new HttpClientHandler
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip
};
this.client = new HttpClient(handlerWithDecompression)
{
BaseAddress = new Uri("http://www.google.com"),
DefaultRequestHeaders =
{
Accept = { MediaTypeWithQualityHeaderValue.Parse("text/html"), MediaTypeWithQualityHeaderValue.Parse("application/xhtml+xml"), MediaTypeWithQualityHeaderValue.Parse("application/xml") },
AcceptEncoding = { StringWithQualityHeaderValue.Parse("gzip"), StringWithQualityHeaderValue.Parse("deflate") },
UserAgent = { ProductInfoHeaderValue.Parse("Chrome/10.0.648.151") }
}
};
}
private static async Task <string> GetJson(string url)
{
using (var client = new HttpClient())
{
using (var message = new HttpRequestMessage(HttpMethod.Get, url))
{
message.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(CONTENTTYPE_JSON));
message.Headers.AcceptEncoding.Add(StringWithQualityHeaderValue.Parse("UTF-8"));
var result = await client.SendAsync(message);
if (result.IsSuccessStatusCode)
{
return(await result.Content.ReadAsStringAsync());
}
}
}
return(null);
}
private void CreateHttpClientOnce()
{
var handler = new HttpClientHandler
{
ClientCertificateOptions = ClientCertificateOption.Automatic,
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,
};
_client = new HttpClient(handler);
_client.DefaultRequestHeaders.Clear();
_client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_client.DefaultRequestHeaders.AcceptEncoding.Add(StringWithQualityHeaderValue.Parse("gzip"));
_client.DefaultRequestHeaders.AcceptEncoding.Add(StringWithQualityHeaderValue.Parse("deflate"));
var credentialsBytes = Encoding.UTF8.GetBytes($"{Config.TppUser}:{Config.TppPassword}");
var credentialsString = Convert.ToBase64String(credentialsBytes);
_client.DefaultRequestHeaders.Add("Authorization", $"Basic {credentialsString}");
}
/// <summary>
/// Sends a HTTP request.
/// </summary>
/// <param name="httpRequest">The <see cref="HttpRequestMessage"/> to be sent.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> for the request.</param>
/// <returns></returns>
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage httpRequest, CancellationToken cancellationToken)
{
StringWithQualityHeaderValue gzipQHeaderValue = new StringWithQualityHeaderValue(CoreConstants.Encoding.GZip);
// Add Accept-encoding: gzip header to incoming request if it doesn't have one.
if (!httpRequest.Headers.AcceptEncoding.Contains(gzipQHeaderValue))
{
httpRequest.Headers.AcceptEncoding.Add(gzipQHeaderValue);
}
HttpResponseMessage response = await base.SendAsync(httpRequest, cancellationToken);
// Decompress response content when Content-Encoding: gzip header is present.
if (ShouldDecompressContent(response))
{
response.Content = new StreamContent(new GZipStream(await response.Content.ReadAsStreamAsync(), CompressionMode.Decompress));
}
return(response);
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (_localizationProvider.LanguageCode != null)
{
request.Headers.AcceptLanguage.Add(StringWithQualityHeaderValue.Parse(_localizationProvider.LanguageCode));
}
if (_localizationProvider.CountryCode != null)
{
request.Headers.Add("VGG-Country", _localizationProvider.CountryCode);
}
if (_localizationProvider.CurrencyCode != null)
{
request.Headers.Add("Accept-Currency", _localizationProvider.CurrencyCode);
}
return(base.SendAsync(request, cancellationToken));
}
public static async Task <GetSharedSecretResponse> GetProvisioningResponse(HttpClient httpClient, string request)
{
var content = new StringContent(request, Encoding.UTF8, "application/xml");
var req = new HttpRequestMessage(HttpMethod.Post, PROVISIONING_URL);
req.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("*/*"));
req.Headers.AcceptEncoding.Add(StringWithQualityHeaderValue.Parse("gzip"));
req.Headers.AcceptEncoding.Add(StringWithQualityHeaderValue.Parse("deflate"));
req.Content = content;
var result = await httpClient.SendAsync(req);
var resultTxt = await result.Content.ReadAsStringAsync();
var retval = XmlHelper.Deserialize <GetSharedSecretResponse>(resultTxt);
return(retval);
}
public void GetHashCode_UseSameAndDifferentValues_SameOrDifferentHashCodes()
{
StringWithQualityHeaderValue value1 = new StringWithQualityHeaderValue("t", 0.123);
StringWithQualityHeaderValue value2 = new StringWithQualityHeaderValue("t", 0.123);
StringWithQualityHeaderValue value3 = new StringWithQualityHeaderValue("T", 0.123);
StringWithQualityHeaderValue value4 = new StringWithQualityHeaderValue("t");
StringWithQualityHeaderValue value5 = new StringWithQualityHeaderValue("x", 0.123);
StringWithQualityHeaderValue value6 = new StringWithQualityHeaderValue("t", 0.5);
StringWithQualityHeaderValue value7 = new StringWithQualityHeaderValue("t", 0.1234);
StringWithQualityHeaderValue value8 = new StringWithQualityHeaderValue("T");
StringWithQualityHeaderValue value9 = new StringWithQualityHeaderValue("x");
Assert.Equal(value1.GetHashCode(), value2.GetHashCode());
Assert.Equal(value1.GetHashCode(), value3.GetHashCode());
Assert.NotEqual(value1.GetHashCode(), value4.GetHashCode());
Assert.NotEqual(value1.GetHashCode(), value5.GetHashCode());
Assert.NotEqual(value1.GetHashCode(), value6.GetHashCode());
Assert.NotEqual(value1.GetHashCode(), value7.GetHashCode());
Assert.Equal(value4.GetHashCode(), value8.GetHashCode());
Assert.NotEqual(value4.GetHashCode(), value9.GetHashCode());
}
public void ComparerSortsListCorrectly(string[] unsorted, string[] expectedSorted)
{
// Arrange
IEnumerable <StringWithQualityHeaderValue> unsortedValues = unsorted.Select(
u => StringWithQualityHeaderValue.Parse(u)
);
IEnumerable <StringWithQualityHeaderValue> expectedSortedValues = expectedSorted.Select(
u => StringWithQualityHeaderValue.Parse(u)
);
// Act
IEnumerable <StringWithQualityHeaderValue> actualSorted =
unsortedValues.OrderByDescending(
m => m,
StringWithQualityHeaderValueComparer.QualityComparer
);
// Assert
Assert.True(expectedSortedValues.SequenceEqual(actualSorted));
}
public override ICompressionProvider GetCompressionProvider(HttpContext context)
{
// e.g. Accept-Encoding: gzip, deflate, sdch
var accept = context.Request.Headers[HeaderNames.AcceptEncoding];
if (!StringValues.IsNullOrEmpty(accept) &&
StringWithQualityHeaderValue.TryParseList(accept, out var unsorted) &&
unsorted != null && unsorted.Count > 0)
{
foreach (var provider in _providers)
{
if (unsorted.Any(
x => StringSegment.Equals(provider.EncodingName, x.Value, StringComparison.Ordinal)))
{
return(provider);
}
}
}
return(base.GetCompressionProvider(context));
}
private static bool TryReadQuality(StringSegment input, StringWithQualityHeaderValue result, ref int index)
{
var current = index;
// See if we have a quality value by looking for "q"
if ((current == input.Length) || ((input[current] != 'q') && (input[current] != 'Q')))
{
return(false);
}
current++; // skip 'q' identifier
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
// If we found "q" it must be followed by "="
if ((current == input.Length) || (input[current] != '='))
{
return(false);
}
current++; // skip '=' separator
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
if (current == input.Length)
{
return(false);
}
if (!HeaderUtilities.TryParseQualityDouble(input, current, out var quality, out var qualityLength))
{
return(false);
}
result._quality = quality;
current = current + qualityLength;
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
index = current;
return(true);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
// Use the value we stored in the Culture property of the caller's state when they connected
if (context.Hub.Context.Request.Headers["Accept-Language"] != null)
{
var lang = context.Hub.Context.Request.Headers["Accept-Language"].Split(new[] { ',' })
.Select(a => StringWithQualityHeaderValue.Parse(a))
.Select(a => new StringWithQualityHeaderValue(a.Value,
a.Quality.GetValueOrDefault(1)))
.OrderByDescending(a => a.Quality)
.Select(x => CultureInfo.GetCultureInfo(x.Value))
.FirstOrDefault();
if (lang != null)
{
Thread.CurrentThread.CurrentUICulture = lang;
Thread.CurrentThread.CurrentCulture = lang;
}
}
return(base.OnBeforeIncoming(context));
}
private void NegotiateEncoding(HttpContext context)
{
var accept = context.Request.Headers.AcceptEncoding;
if (StringValues.IsNullOrEmpty(accept))
{
return;
}
if (!StringWithQualityHeaderValue.TryParseList(accept, out var encodings) || encodings.Count == 0)
{
return;
}
var selectedEncoding = StringSegment.Empty;
var selectedEncodingQuality = .0;
foreach (var encoding in encodings)
{
var encodingName = encoding.Value;
var quality = encoding.Quality.GetValueOrDefault(1);
if (quality >= double.Epsilon && quality >= selectedEncodingQuality)
{
if (quality == selectedEncodingQuality)
{
selectedEncoding = PickPreferredEncoding(context, selectedEncoding, encoding);
}
else if (_encodingExtensionMap.TryGetValue(encodingName, out var encodingExtension) && ResourceExists(context, encodingExtension))
{
selectedEncoding = encodingName;
selectedEncodingQuality = quality;
}
if (StringSegment.Equals("*", encodingName, StringComparison.Ordinal))
{
// If we *, pick the first preferrent encoding for which a resource exists.
selectedEncoding = PickPreferredEncoding(context, default, encoding);
public void Equals_UseSameAndDifferentRanges_EqualOrNotEqualNoExceptions()
{
StringWithQualityHeaderValue value1 = new StringWithQualityHeaderValue("t", 0.123);
StringWithQualityHeaderValue value2 = new StringWithQualityHeaderValue("t", 0.123);
StringWithQualityHeaderValue value3 = new StringWithQualityHeaderValue("T", 0.123);
StringWithQualityHeaderValue value4 = new StringWithQualityHeaderValue("t");
StringWithQualityHeaderValue value5 = new StringWithQualityHeaderValue("x", 0.123);
StringWithQualityHeaderValue value6 = new StringWithQualityHeaderValue("t", 0.5);
StringWithQualityHeaderValue value7 = new StringWithQualityHeaderValue("t", 0.1234);
StringWithQualityHeaderValue value8 = new StringWithQualityHeaderValue("T");
StringWithQualityHeaderValue value9 = new StringWithQualityHeaderValue("x");
Assert.False(value1.Equals(null), "t; q=0.123 vs. <null>");
Assert.True(value1.Equals(value2), "t; q=0.123 vs. t; q=0.123");
Assert.True(value1.Equals(value3), "t; q=0.123 vs. T; q=0.123");
Assert.False(value1.Equals(value4), "t; q=0.123 vs. t");
Assert.False(value4.Equals(value1), "t vs. t; q=0.123");
Assert.False(value1.Equals(value5), "t; q=0.123 vs. x; q=0.123");
Assert.False(value1.Equals(value6), "t; q=0.123 vs. t; q=0.5");
Assert.False(value1.Equals(value7), "t; q=0.123 vs. t; q=0.1234");
Assert.True(value4.Equals(value8), "t vs. T");
Assert.False(value4.Equals(value9), "t vs. T");
}
private static void ConfigureHttpClient(Uri baseAddress, HttpMessageHandler handler)
{
Client.BaseAddress = baseAddress;
Client.DefaultRequestHeaders.AcceptEncoding.Add(StringWithQualityHeaderValue.Parse("gzip"));
Client.DefaultRequestHeaders.AcceptEncoding.Add(StringWithQualityHeaderValue.Parse("defalte"));
Client.DefaultRequestHeaders.UserAgent.Add(GetUserAgent());
Client.DefaultRequestHeaders.Accept.Clear();
foreach (var mediaTypeHeader in Formatters.SelectMany(x => x.SupportedMediaTypes))
{
Client.DefaultRequestHeaders.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(mediaTypeHeader.MediaType));
}
var clientHandler = handler as HttpClientHandler;
if (clientHandler == null)
{
return;
}
clientHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
}
public async Task Invoke(HttpContext context)
{
var encodings = context.Request.Headers[HeaderNames.AcceptEncoding];
if (!StringValues.IsNullOrEmpty(encodings) &&
StringWithQualityHeaderValue.TryParseList(encodings, out var encodingsList) &&
encodingsList != null &&
encodingsList.Count > 0)
{
var encodingsWithQuality = new string[encodingsList.Count];
for (var encodingIndex = 0; encodingIndex < encodingsList.Count; encodingIndex++)
{
// If there is any quality value provided don't change anything
if (encodingsList[encodingIndex].Quality.HasValue)
{
encodingsWithQuality = null;
break;
}
var encodingValue = encodingsList[encodingIndex].Value.ToString();
encodingsWithQuality[encodingIndex] =
new StringWithQualityHeaderValue(
encodingValue,
_encodingQuality.ContainsKey(encodingValue)
? _encodingQuality[encodingValue]
: 0.1).ToString();
}
if (encodingsWithQuality != null)
{
context.Request.Headers[HeaderNames.AcceptEncoding] = new StringValues(encodingsWithQuality);
}
}
await _next(context);
}
public void TryParseList_WithSomeInvalidValues_IgnoresInvalidValues()
{
var inputs = new[]
{
"",
"text1",
"text 1",
"text2",
"\"text 2\",",
"text3;q=0.5",
"text4;q=0.5, extra stuff",
" text5 ; q = 0.50 ",
"\r\n text6 ; q = 0.05 ",
"text7,text8;q=0.5",
" text9 , text10 ; q = 0.5 ",
};
Assert.True(StringWithQualityHeaderValue.TryParseList(inputs, out var results));
var expectedResults = new[]
{
new StringWithQualityHeaderValue("text1"),
new StringWithQualityHeaderValue("1"),
new StringWithQualityHeaderValue("text2"),
new StringWithQualityHeaderValue("text3", 0.5),
new StringWithQualityHeaderValue("text4", 0.5),
new StringWithQualityHeaderValue("stuff"),
new StringWithQualityHeaderValue("text5", 0.5),
new StringWithQualityHeaderValue("text6", 0.05),
new StringWithQualityHeaderValue("text7"),
new StringWithQualityHeaderValue("text8", 0.5),
new StringWithQualityHeaderValue("text9"),
new StringWithQualityHeaderValue("text10", 0.5),
}.ToList();
Assert.Equal(expectedResults, results);
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpHeaderValueCollection <StringWithQualityHeaderValue> acceptedLanguages = request.Headers.AcceptLanguage;
if (acceptedLanguages.IsNotNullOrEmpty())
{
StringWithQualityHeaderValue headerValue = acceptedLanguages.OrderByDescending(e => e.Quality ?? 1.0D)
.Where(e => !e.Quality.HasValue || e.Quality.Value > 0.0D)
.FirstOrDefault(e => supportedCultures.Contains(e.Value, StringComparer.OrdinalIgnoreCase));
string culture = null;
// Case 1: We can support what client has asked for
if (headerValue.IsNotNull())
{
culture = headerValue.Value;
}
// Case 2: Client is okay to accept any thing we support except
// the ones explicitly specified as not preferred by setting q=0
else if (acceptedLanguages.Any(e => e.Value == "*" && (!e.Quality.HasValue || e.Quality.Value > 0.0D)))
{
culture = supportedCultures.Where(sc =>
!acceptedLanguages.Any(e =>
e.Value.Equals(sc, StringComparison.OrdinalIgnoreCase) &&
e.Quality.HasValue &&
e.Quality.Value == 0.0D))
.FirstOrDefault();
}
if (culture.IsNotNull())
{
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(culture);
Thread.CurrentThread.CurrentCulture = Thread.CurrentThread.CurrentUICulture;
}
}
return(await base.SendAsync(request, cancellationToken));
}
/// <summary>
/// 创建HttpClient
/// </summary>
/// <param name="apiAuthentication"></param>
/// <returns>HttpClient</returns>
private static HttpClient PrepareHttpClient(ApiAuthenticationEnum apiAuthentication, string data = "")
{
var handler = new HttpClientHandler
{
AllowAutoRedirect = false,
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
};
// ssl请求
//handler.ServerCertificateCustomValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;正式环境报错：他处理程序不支持自定义与此结合证书处理
var httpClient = new HttpClient(handler);
var authentication = GetAuthenticationHeaderValue(apiAuthentication);
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
string salt = getsalt(), passid = getpassid(salt, data), timestamp = gettime(), signature = getsign(timestamp, salt, passid, data);
httpClient.DefaultRequestHeaders.Add("passid", passid);
httpClient.DefaultRequestHeaders.Add("timestamp", timestamp);
httpClient.DefaultRequestHeaders.Add("salt", salt);
httpClient.DefaultRequestHeaders.Add("signature", signature);
httpClient.DefaultRequestHeaders.AcceptEncoding.Add(StringWithQualityHeaderValue.Parse("gzip"));
httpClient.DefaultRequestHeaders.Authorization = authentication;
return(httpClient);
}
public void TryParseStrictList_SetOfValidValueStrings_ParsedCorrectly()
{
var inputs = new[]
{
"",
"text1",
"text2,",
"textA,textB",
"text3;q=0.5",
"text4;q=0.5,",
" text5 ; q = 0.50 ",
"\r\n text6 ; q = 0.05 ",
"text7,text8;q=0.5",
" text9 , text10 ; q = 0.5 ",
};
Assert.True(StringWithQualityHeaderValue.TryParseStrictList(inputs, out var results));
var expectedResults = new[]
{
new StringWithQualityHeaderValue("text1"),
new StringWithQualityHeaderValue("text2"),
new StringWithQualityHeaderValue("textA"),
new StringWithQualityHeaderValue("textB"),
new StringWithQualityHeaderValue("text3", 0.5),
new StringWithQualityHeaderValue("text4", 0.5),
new StringWithQualityHeaderValue("text5", 0.5),
new StringWithQualityHeaderValue("text6", 0.05),
new StringWithQualityHeaderValue("text7"),
new StringWithQualityHeaderValue("text8", 0.5),
new StringWithQualityHeaderValue("text9"),
new StringWithQualityHeaderValue("text10", 0.5),
}.ToList();
Assert.Equal(expectedResults, results);
}
public async Task ShouldSetAcceptCharsetHeaderInRequest()
{
// arrange
const string requestUri = "/fake";
const double quality = 1;
const string charset = "utf-8";
string value = $"{charset};q={quality}";
HttpClient client = new HttpClient();
IHttpClientVerbBuilder <HttpClient> builder = new HttpClientVerbBuilder <HttpClient>(client);
// act
HttpRequestMessage httpRequest = await client
.Request()
.Get(requestUri)
.Header("Accept-Charset", value)
.BuildHttpRequestAsync();
StringWithQualityHeaderValue header = httpRequest.Headers.AcceptCharset.FirstOrDefault();
// assert
Assert.NotNull(header);
Assert.StrictEqual(header.Quality, quality);
Assert.True(header.Value == charset);
}
/// <inheritdoc />
public virtual ICompressionProvider?GetCompressionProvider(HttpContext context)
{
// e.g. Accept-Encoding: gzip, deflate, sdch
var accept = context.Request.Headers.AcceptEncoding;
// Note this is already checked in CheckRequestAcceptsCompression which _should_ prevent any of these other methods from being called.
if (StringValues.IsNullOrEmpty(accept))
{
Debug.Assert(false, "Duplicate check failed.");
_logger.NoAcceptEncoding();
return(null);
}
if (!StringWithQualityHeaderValue.TryParseList(accept, out var encodings) || encodings.Count == 0)
{
_logger.NoAcceptEncoding();
return(null);
}
var candidates = new HashSet <ProviderCandidate>();
foreach (var encoding in encodings)
{
var encodingName = encoding.Value;
var quality = encoding.Quality.GetValueOrDefault(1);
if (quality < double.Epsilon)
{
continue;
}
for (int i = 0; i < _providers.Length; i++)
{
var provider = _providers[i];
if (StringSegment.Equals(provider.EncodingName, encodingName, StringComparison.OrdinalIgnoreCase))
{
candidates.Add(new ProviderCandidate(provider.EncodingName, quality, i, provider));
}
}
// Uncommon but valid options
if (StringSegment.Equals("*", encodingName, StringComparison.Ordinal))
{
for (int i = 0; i < _providers.Length; i++)
{
var provider = _providers[i];
// Any provider is a candidate.
candidates.Add(new ProviderCandidate(provider.EncodingName, quality, i, provider));
}
break;
}
if (StringSegment.Equals("identity", encodingName, StringComparison.OrdinalIgnoreCase))
{
// We add 'identity' to the list of "candidates" with a very low priority and no provider.
// This will allow it to be ordered based on its quality (and priority) later in the method.
candidates.Add(new ProviderCandidate(encodingName.Value, quality, priority: int.MaxValue, provider: null));
}
}
ICompressionProvider?selectedProvider = null;
if (candidates.Count <= 1)
{
selectedProvider = candidates.FirstOrDefault().Provider;
}
else
{
selectedProvider = candidates
.OrderByDescending(x => x.Quality)
.ThenBy(x => x.Priority)
.First().Provider;
}
if (selectedProvider == null)
{
// "identity" would match as a candidate but not have a provider implementation
_logger.NoCompressionProvider();
return(null);
}
_logger.CompressingWith(selectedProvider.EncodingName);
return(selectedProvider);
}
private ICompressor GetCompressor(IOwinRequest request)
{
if (!request.Headers.ContainsKey(AcceptEncoding))
{
return(null);
}
return((from c in compressors
from e in request.Headers.GetCommaSeparatedValues(AcceptEncoding).Select(x => StringWithQualityHeaderValue.Parse(x))
orderby e.Quality descending
where string.Compare(c.ContentEncoding, e.Value, StringComparison.InvariantCultureIgnoreCase) == 0
select c).FirstOrDefault());
}
/// <summary>
/// Attempts to parse the specified <paramref name="input"/> as a <see cref="StringWithQualityHeaderValue"/>.
/// </summary>
/// <param name="input">The value to parse.</param>
/// <param name="parsedValue">The parsed value.</param>
/// <returns><see langword="true"/> if input is a valid <see cref="StringWithQualityHeaderValue"/>, otherwise <see langword="false"/>.</returns>
public static bool TryParse(StringSegment input, [NotNullWhen(true)] out StringWithQualityHeaderValue parsedValue)
{
var index = 0;
return(SingleValueParser.TryParseValue(input, ref index, out parsedValue !));
}
public void Ctor()
{
var a = new StringWithQualityHeaderValue("s", 0.123456);
Assert.AreEqual("s; q=0.123", a.ToString());
}
private void CheckInvalidParse(string input)
{
Assert.Throws <FormatException>(() => { StringWithQualityHeaderValue.Parse(input); });
}
private void CheckValidParse(string input, StringWithQualityHeaderValue expectedResult)
{
StringWithQualityHeaderValue result = StringWithQualityHeaderValue.Parse(input);
Assert.Equal(expectedResult, result);
}
public static bool TryParse (string input, out StringWithQualityHeaderValue parsedValue)
{
throw new NotImplementedException ();
}
