/// <summary>
/// Parses a <see cref="RequestCulture"/> from the specified cookie value.
/// Returns <c>null</c> if parsing fails.
/// </summary>
/// <param name="value">The cookie value to parse.</param>
/// <returns>The <see cref="RequestCulture"/> or <c>null</c> if parsing fails.</returns>
public static RequestCulture ParseCookieValue([NotNull] string value)
{
if (string.IsNullOrWhiteSpace(value))
{
return(null);
}
var parts = value.Split(_cookieSeparator, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
{
return(null);
}
var potentialCultureName = parts[0];
var potentialUICultureName = parts[1];
if (!potentialCultureName.StartsWith(_culturePrefix) || !potentialUICultureName.StartsWith(_uiCulturePrefix))
{
return(null);
}
var cultureName = potentialCultureName.Substring(_culturePrefix.Length);
var uiCultureName = potentialUICultureName.Substring(_uiCulturePrefix.Length);
var culture = CultureInfoCache.GetCultureInfo(cultureName);
var uiCulture = CultureInfoCache.GetCultureInfo(uiCultureName);
if (culture == null || uiCulture == null)
{
return(null);
}
return(new RequestCulture(culture, uiCulture));
}
/// <inheritdoc />
public override Task <RequestCulture> DetermineRequestCulture([NotNull] HttpContext httpContext)
{
var request = httpContext.Request;
if (!request.QueryString.HasValue)
{
return(Task.FromResult((RequestCulture)null));
}
string queryCulture = null;
string queryUICulture = null;
if (!string.IsNullOrWhiteSpace(QueryStringKey))
{
queryCulture = request.Query[QueryStringKey];
}
if (!string.IsNullOrWhiteSpace(UIQueryStringKey))
{
queryUICulture = request.Query[UIQueryStringKey];
}
if (queryCulture == null && queryUICulture == null)
{
// No values specified for either so no match
return(Task.FromResult((RequestCulture)null));
}
if (queryCulture != null && queryUICulture == null)
{
// Value for culture but not for UI culture so default to culture value for both
queryUICulture = queryCulture;
}
if (queryCulture == null && queryUICulture != null)
{
// Value for UI culture but not for culture so default to UI culture value for both
queryCulture = queryUICulture;
}
var culture = CultureInfoCache.GetCultureInfo(queryCulture);
var uiCulture = CultureInfoCache.GetCultureInfo(queryUICulture);
if (culture == null || uiCulture == null)
{
return(Task.FromResult((RequestCulture)null));
}
var requestCulture = new RequestCulture(culture, uiCulture);
requestCulture = ValidateRequestCulture(requestCulture);
return(Task.FromResult(requestCulture));
}
private CultureInfo GetCultureInfo(IList <string> cultures, IList <CultureInfo> supportedCultures)
{
foreach (var culture in cultures)
{
// Allow empty string values as they map to InvariantCulture, whereas null culture values will throw in
// the CultureInfo ctor
if (culture != null)
{
var cultureInfo = CultureInfoCache.GetCultureInfo(culture, supportedCultures);
if (cultureInfo != null)
{
return(cultureInfo);
}
}
}
return(null);
}
private CultureInfo GetCultureInfoFromUrl(HttpContext context)
{
var currentCulture = "en";
var segments = context.Request.Path.Value.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Length > 1 && segments[0].Length == 2)
{
if (CultureInfoCache.KnownCultureNames.Contains(segments[0]))
{
currentCulture = segments[0];
}
else
{
throw new InvalidOperationException($"The '{segments[0]}' is invalid culture name.");
}
}
return(CultureInfoCache.GetCultureInfo(currentCulture));
}
/// <inheritdoc />
public override Task <RequestCulture> DetermineRequestCulture([NotNull] HttpContext httpContext)
{
var acceptLanguageHeader = httpContext.Request.GetTypedHeaders().AcceptLanguage;
if (acceptLanguageHeader == null || acceptLanguageHeader.Count == 0)
{
return(Task.FromResult((RequestCulture)null));
}
var languages = acceptLanguageHeader.AsEnumerable();
if (MaximumAcceptLanguageHeaderValuesToTry > 0)
{
// We take only the first configured number of languages from the header and then order those that we
// attempt to parse as a CultureInfo to mitigate potentially spinning CPU on lots of parse attempts.
languages = languages.Take(MaximumAcceptLanguageHeaderValuesToTry);
}
var orderedLanguages = languages.OrderByDescending(h => h, StringWithQualityHeaderValueComparer.QualityComparer)
.ToList();
foreach (var language in orderedLanguages)
{
// Allow empty string values as they map to InvariantCulture, whereas null culture values will throw in
// the CultureInfo ctor
if (language.Value != null)
{
var culture = CultureInfoCache.GetCultureInfo(language.Value);
if (culture != null)
{
var requestCulture = new RequestCulture(culture);
requestCulture = ValidateRequestCulture(requestCulture);
if (requestCulture != null)
{
return(Task.FromResult(requestCulture));
}
}
}
}
return(Task.FromResult((RequestCulture)null));
}
private static CultureInfo GetCultureInfo(
string cultureName,
IList <CultureInfo> supportedCultures,
bool fallbackToParentCultures,
int currentDepth)
{
var culture = CultureInfoCache.GetCultureInfo(cultureName, supportedCultures);
if (culture == null && fallbackToParentCultures && currentDepth < MaxCultureFallbackDepth)
{
var lastIndexOfHyphen = cultureName.LastIndexOf('-');
if (lastIndexOfHyphen > 0)
{
// Trim the trailing section from the culture name, e.g. "fr-FR" becomes "fr"
var parentCultureName = cultureName.Substring(0, lastIndexOfHyphen);
culture = GetCultureInfo(parentCultureName, supportedCultures, fallbackToParentCultures, currentDepth + 1);
}
}
return(culture);
}
