public static void Add(string languageTag, ILanguageTag languageTagInstance)
{
if (languageTag.IsNullOrWhiteSpace())
{
return;
}
if (languageTagInstance == null)
{
return;
}
var hashOfLanguageTag = languageTag.GetHashCode();
if (Contains(hashOfLanguageTag))
{
return;
}
lock (_lockObj) {
if (Contains(hashOfLanguageTag))
{
return;
}
_languageTags.Add(hashOfLanguageTag, languageTagInstance);
}
}
/// <summary>
/// Create
/// </summary>
/// <param name="text"></param>
/// <param name="packageKey"></param>
/// <param name="formatProvider"></param>
/// <param name="languageTag"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public IText Create(string text, string packageKey,
Func <string, ILanguageTag, string, object[], string> formatProvider,
ILanguageTag languageTag, params object[] parameters)
{
return(new Text(_translationProcessor, text, packageKey, languageTag, parameters)
{
CustomFormatProvider = formatProvider
});
}
public static bool TryGet(string languageTag, out ILanguageTag result)
{
result = null;
if (Contains(languageTag))
{
return(_languageTags.TryGetValue(languageTag.GetHashCode(), out result));
}
return(false);
}
// Con
public LanguageItem(
ILanguageTag i_LanguageTag,
float i_Quality,
int i_Ordinal)
{
LanguageTag = i_LanguageTag;
Quality = i_Quality;
Ordinal = i_Ordinal;
UseCount = 0;
}
/// <summary>
/// Create a new instance of <see cref="Text"/>.
/// </summary>
/// <param name="text"></param>
/// <param name="packageKey"></param>
/// <param name="languageTag"></param>
/// <param name="parameters"></param>
public Text(string text, string packageKey, ILanguageTag languageTag, params object[] parameters)
{
LanguageTag = languageTag as LanguageTag ?? LanguageTag.Current;
PackageKey = packageKey;
OriginText = text;
FormatingParameters = parameters;
_translationProcessor = StaticInstanceForILanguageServiceProvider.Instance.GetTranslationProcessor();
CustomFormatProvider = (packageKeyArg, languageTagArg, textArg, parametersArg) => string.Format(textArg, parametersArg);
}
/// <summary>
/// Create a new instance of <see cref="Text"/>.
/// </summary>
/// <param name="processor"></param>
/// <param name="text"></param>
/// <param name="packageKey"></param>
/// <param name="languageTag"></param>
/// <param name="parameters"></param>
public Text(TranslationProcessor processor, string text, string packageKey, ILanguageTag languageTag, params object[] parameters)
{
LanguageTag = languageTag as LanguageTag ?? LanguageTag.Current;
PackageKey = packageKey;
OriginText = text;
FormatingParameters = parameters;
_translationProcessor = processor ?? throw new ArgumentNullException(nameof(processor));
CustomFormatProvider = (packageKeyArg, languageTagArg, textArg, parametersArg) => string.Format(textArg, parametersArg);
}
public static ILanguageTag GetPrincipalAppLanguageForRequest(this HttpContextBase context)
{
// The PAL is stored as the first item in the UserLanguages array (with Quality set to 2).
//
ILanguageTag langtag = GetRequestUserLanguages(context)[0].LanguageTag;
if (langtag == null)
{
langtag = LocalizedApplication.Current.DefaultLanguageTag;
}
return(langtag);
}
public static void SetPrincipalAppLanguageForRequest(this HttpContextBase context, ILanguageTag pal, bool updateThreadCulture = true)
{
// The PAL is stored as the first item in the UserLanguages array (with Quality set to 2).
//
LanguageItem[] UserLanguages = GetRequestUserLanguages(context);
UserLanguages[0] = new LanguageItem(pal, LanguageItem.PalQualitySetting, 0);
// Run through any handlers installed for this event.
if (LocalizedApplication.Current.SetPrincipalAppLanguageForRequestHandlers != null)
{
foreach (LocalizedApplication.SetLanguageHandler handler in LocalizedApplication.Current.SetPrincipalAppLanguageForRequestHandlers.GetInvocationList())
{
handler(context, pal);
}
}
}
/// <summary>
/// Helper for caching a per-request value that identifies the principal language
/// under which the current request is to be handled.
/// </summary>
/// <param name="context">Context of the request.</param>
/// <param name="pal">Selected AppLanguage aka Principle Application Language (PAL).</param>
/// <param name="updateThreadCulture">
/// Indicates whether to also update the thread CurrentCulture/CurrentUICulture settings.
/// </param>
public static void SetPrincipalAppLanguageForRequest(this HttpContext context, ILanguageTag pal, bool updateThreadCulture = true)
{
context.GetHttpContextBase().SetPrincipalAppLanguageForRequest(pal, updateThreadCulture);
}
public static bool IsValid(this ILanguageTag languageTag) => languageTag != null && languageTag.GetLanguage() != null;
// [IComparable<ILanguageTag>]
/// <summary>
/// CompareTo
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public int CompareTo(ILanguageTag other)
{
return(string.Compare(OriginalLanguageTag, other.ToString(), StringComparison.OrdinalIgnoreCase));
}
// [IEquatable<ILanguageTag>]
/// <summary>
/// Equals
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool Equals(ILanguageTag other)
{
return(0 == string.Compare(OriginalLanguageTag, other.ToString(), StringComparison.OrdinalIgnoreCase));
}
static string CustomFormatProvider(string packageKey, ILanguageTag languageTag, string text, object[] parameters)
{
return($"Custom format result: {string.Format(text, parameters)}, LangTag: {languageTag}");
}
/// <summary>
/// Create a new instance of <see cref="Text"/>.
/// </summary>
/// <param name="text"></param>
/// <param name="packageKey"></param>
/// <param name="languageTag"></param>
public Text(string text, string packageKey, ILanguageTag languageTag)
: this(text, packageKey, languageTag, null)
{
}
public static void SetPrincipalAppLanguageForRequest(this System.Web.HttpContextBase context, ILanguageTag pal, bool updateThreadCulture = true)
{
// The PAL is stored as the first item in the UserLanguages array (with Quality set to 2).
//
LanguageItem[] UserLanguages = GetRequestUserLanguages(context);
UserLanguages[0] = new LanguageItem(pal, LanguageItem.PalQualitySetting, 0);
// Run through any handlers installed for this event.
if (LocalizedApplication.Current.SetPrincipalAppLanguageForRequestHandlers != null) {
foreach (LocalizedApplication.SetLanguageHandler handler in LocalizedApplication.Current.SetPrincipalAppLanguageForRequestHandlers.GetInvocationList())
{
handler(context, pal);
}
}
}
// [IComparable<ILanguageTag>]
public int CompareTo(ILanguageTag other)
{
return(string.Compare(m_langtag, other.ToString(), true));
}
// Static helpers
/// <summary>
/// Parses an HTTP Accept-Language or Content-Language header value, returning
/// a representative ordered array of LanguageItem instances, sorted in order of
/// language preference.
/// E.g. "de;q=0.5, en;q=1, fr-FR;q=0,ga;q=0.5".
/// Notably, is able to re-order elements based on quality.
/// </summary>
/// <remarks>
/// The first element position in the returned array is reserved for an item that
/// describes the Principal Application Language (PAL) for the request. If/when the PAL
/// is not set, that element will be a null item (LanguageItem.LanguageTag == null).
///
/// This method is designed to be as efficient as possible, typically requiring
/// only a single heap alloc, for the returned array object itself.
/// </remarks>
/// <param name="headerval">
/// HTTP Accept-Language header value.
/// http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html.
/// May be null or empty string for zero languages.
/// </param>
/// <param name="pal">
/// Optional language to store at the first element position in the array, which is reserved
/// for the Principal Application Language (PAL). Any such LanguageItem stored that has a quality
/// value of 2 (LanguageItem.PalQualitySetting). Null if no such language to be stored there and the
/// item to be set as null (LanguageItem.LanguageTag == null).
/// </param>
/// <returns>
/// Array of languages items (with possibly null LanguageTag members) sorted in order or language preference.
/// </returns>
public static LanguageItem[] ParseHttpLanguageHeader(string headerval, ILanguageTag pal = null)
{
// This method is designed to be as efficient as possible (avoiding string allocations where possible).
//
int begin, end, pos1;
int len = headerval != null ? headerval.Length : 0;
int ordinal = 0;
// Init array with enough elements for each language entry in the header.
var LanguageItems = new LanguageItem[(len > 0 ? headerval.CountOfChar(',') + 1 : 0) + 1];
// First element position is reserved for any PAL.
LanguageItems[ordinal] = new LanguageItem(pal, PalQualitySetting, ordinal);
++ordinal;
// For each language component of the header (delimited by comma)
for (begin = 0; begin < len; begin = end + 1)
{
end = headerval.IndexOf(',', begin);
if (-1 == end)
{
end = len;
}
float qvalue = 1;
pos1 = headerval.IndexOf(';', begin);
if (-1 != pos1 &&
pos1 < end)
{
// pos1 -> ";q=n"
if (pos1 - begin < 2 || // room for valid langtag
pos1 + 3 >= headerval.Length ||
headerval[pos1 + 1] != 'q' ||
headerval[pos1 + 2] != '=')
{
continue;
}
if (!ParseHelpers.TryParseDecimal(headerval, pos1 + 3, -1, out qvalue))
{
continue;
}
if (qvalue < 0f || qvalue > 1.0f)
{
continue;
}
}
else
{
pos1 = end;
}
// Skip over any whitespace. We expect this to make the following Trim redundant,
// thus saving on an alloc.
while (headerval[begin] == ' ')
{
++begin;
}
// Extract language subtag e.g. "fr-FR".
// NB: we expect this to be efficient and not allocate a new string as
// a string matching the trimmed value is most likely already Intern (held by
// the LanguageTag cache as a key value). Only first time here for a particular
// value will a new string possibly be allocated.
string langtag = headerval.Substring(begin, pos1 - begin).Trim();
// Wrap langtag.
LanguageTag lt = i18n.LanguageTag.GetCachedInstance(langtag);
if (lt == null || !lt.Language.IsSet())
{
continue;
}
// Ignore the langtag if already added.
//if (pal.IsValid() && pal.Equals(lt)) {
// continue; }
// NB: the above check disabled as it can cause the first lang in the header,
// where it matches the PAL intially, to be lost if/when the PAL is later changed
// to something else.
// Store a new representative item.
// NB: LanguageItem is a value type so no alloc done here.
LanguageItems[ordinal] = new LanguageItem(lt, qvalue, ordinal);
++ordinal;
}
// Truncate any extra elements from end of array.
if (ordinal != LanguageItems.Length)
{
LanguageItems = LanguageItems.Where(x => x.LanguageTag.IsValid()).ToArray();
}
// If there was no PAL, and the header value was invalid then we will have no language items, so add the default
if (LanguageItems.Length == 0)
{
LanguageItems = new LanguageItem[] { new LanguageItem(LocalizedApplication.Current.DefaultLanguageTag, PalQualitySetting, 0) }
}
;
// Rearrange items into order of precedence. This is facilitated by LanguageItem's
// impl. of IComparable.
Array.Sort(LanguageItems);
// Done.
return(LanguageItems);
}
}
/// <summary>
/// Create
/// </summary>
/// <param name="text"></param>
/// <param name="packageKey"></param>
/// <param name="languageTag"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public IText Create(string text, string packageKey, ILanguageTag languageTag, params object[] parameters)
{
return(new Text(_translationProcessor, text, packageKey, languageTag, parameters));
}
/// <summary>
/// Create
/// </summary>
/// <param name="text"></param>
/// <param name="packageKey"></param>
/// <param name="languageTag"></param>
/// <returns></returns>
public IText Create(string text, string packageKey, ILanguageTag languageTag)
{
return(new Text(_translationProcessor, text, packageKey, languageTag));
}
/// <summary>
/// Create
/// </summary>
/// <param name="text"></param>
/// <param name="formatProvider"></param>
/// <param name="languageTag"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public IText Anonymous(string text, Func <string, ILanguageTag, string, object[], string> formatProvider, ILanguageTag languageTag, params object[] parameters)
{
return(new Text(_translationProcessor, text, TranslationManager.ANONYMOUS_PACKAGE_KEY, languageTag, parameters)
{
CustomFormatProvider = formatProvider
});
}
/// <summary>
/// Create
/// </summary>
/// <param name="text"></param>
/// <param name="languageTag"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public IText Anonymous(string text, ILanguageTag languageTag, params object[] parameters)
{
return(new Text(_translationProcessor, text, TranslationManager.ANONYMOUS_PACKAGE_KEY, languageTag, parameters));
}
// [IEquatable<ILanguageTag>]
public bool Equals(ILanguageTag other)
{
return(0 == string.Compare(m_langtag, other.ToString(), true));
}
/// <summary>
/// Create a new instance of <see cref="Text"/>.
/// </summary>
/// <param name="processor"></param>
/// <param name="text"></param>
/// <param name="packageKey"></param>
/// <param name="languageTag"></param>
public Text(TranslationProcessor processor, string text, string packageKey, ILanguageTag languageTag)
: this(processor, text, packageKey, languageTag, null)
{
}
public static bool IsValid(
this ILanguageTag lt)
{
return(lt != null && lt.GetLanguage() != null);
}
/// <summary>
/// Helper for caching a per-request value that identifies the principal language
/// under which the current request is to be handled.
/// </summary>
/// <param name="context">Context of the request.</param>
/// <param name="pal">Selected AppLanguage aka Principle Application Language (PAL).</param>
/// <param name="updateThreadCulture">
/// Indicates whether to also update the thread CurrentCulture/CurrentUICulture settings.
/// </param>
public static void SetPrincipalAppLanguageForRequest(this System.Web.HttpContext context, ILanguageTag pal, bool updateThreadCulture = true)
{
context.GetHttpContextBase().SetPrincipalAppLanguageForRequest(pal, updateThreadCulture);
}
