internal CultureFileCache(IHostingEnvironment env, ICultureOption cultureOption, int cultureCacheSize, int perCultureCacheSize)
{
this.env = env;
this.cultureOption = cultureOption;
this.perCultureCacheSize = perCultureCacheSize;
this.cultureCache = new Cache <string, CultureFilePage>(cultureCacheSize);
}
public static IServiceCollection AddMvcLocalization(
this IServiceCollection services,
string defaultCulture,
IEnumerable <string> supportedCultures,
int culturePageCacheSize = 100,
int cultureCacheSize = 20)
{
services.AddSingleton <ICultureOption>(new CultureOption(defaultCulture, supportedCultures));
services.AddSingleton <ICultureFileCache>(provider =>
{
IHostingEnvironment env = provider.GetRequiredService <IHostingEnvironment>();
ICultureOption cultureOption = provider.GetRequiredService <ICultureOption>();
return(new CultureFileCache(env, cultureOption, cultureCacheSize, culturePageCacheSize));
});
services.AddSingleton <ICultureFileCollectionCache>(provider =>
{
IHostingEnvironment env = provider.GetRequiredService <IHostingEnvironment>();
return(new CultureFileCollectionCache(env, cultureCacheSize, culturePageCacheSize));
});
services.AddScoped <ICultureContext, CultureContext>();
services.AddSingleton <CultureMatchingViewResultExecutor>();
services.AddScoped <ILocalizedViewRenderContextAccessor, LocalizedViewRenderContextAccessor>();
services.AddScoped <ILocalizedViewRenderContext>(service =>
{
ILocalizedViewRenderContextAccessor accessor = service.GetRequiredService <ILocalizedViewRenderContextAccessor>();
if (accessor.Context == null)
{
ICultureContext cultureContext = service.GetRequiredService <ICultureContext>();
accessor.Context = new LocalizedViewRenderContext(cultureContext.CurrentCulture, cultureContext.CurrentCulture, cultureContext.UrlCultureSpecifier);
}
return(accessor.Context);
});
return(services);
}
private ICultureExpression ExtractLanguageFromUrl(HttpContext context, ICultureContext cultureContext, out string urlSpecifier, out string action)
{
ICultureOption cultureOption = cultureContext.CultureOption;
string path = context.Request.Path.Value;
if (UrlComponents.TryParse(path, out UrlComponents urlComponents))
{
action = urlComponents.Action;
context.Request.Path = new PathString(action);
urlSpecifier = urlComponents.CultureSpecifier ?? "";
if (urlSpecifier.Length > 0)
{
context.Request.PathBase = context.Request.PathBase.Add(new PathString(urlSpecifier));
}
if (urlComponents.Culture != null && checkCultureSupported && !cultureContext.CultureOption.IsCultureSupported(urlComponents.Culture))
{
return(null);
}
return(urlComponents.Culture);
}
else
{
urlSpecifier = "";
action = path;
return(null);
}
}
private ICultureExpression ExtractLanguageFromHeader(HttpContext context, ICultureContext cultureContext)
{
ICultureOption cultureOption = cultureContext.CultureOption;
StringValues languageValues;
if (!context.Request.Headers.TryGetValue("Accept-Language", out languageValues))
{
return(null);
}
List <string> languageCodes = new List <string>();
foreach (string lang in languageValues)
{
languageCodes.AddRange(lang.Split(';').Select(x => x.ToLower()));
}
ICultureExpression expression;
foreach (string lang in languageCodes)
{
if (lang.TryParseCultureExpression(out expression))
{
if (checkCultureSupported && !cultureContext.CultureOption.IsCultureSupported(expression))
{
return(null);
}
return(expression);
}
}
return(null);
}
public static bool TryFindFile(
string directory,
string fileName,
string extension,
ICultureExpression requestedCulture,
IHostingEnvironment env,
ICultureOption cultureOption,
out IFileCultureInfo result)
{
// match requested
if (TryFindFile(directory, fileName, extension, env, requestedCulture, out result))
{
return(true);
}
// match default
if (TryFindFile(directory, fileName, extension, env, cultureOption.DefaultCulture, out result))
{
return(true);
}
// match no language
string targetName = $"{fileName}.{extension}";
IFileInfo file = env.ContentRootFileProvider.GetFileInfo(Path.Combine(directory, targetName));
if (file.Exists && !file.IsDirectory)
{
result = new FileCultureInfo($"{directory}/{targetName}", targetName, fileName, extension, null);
return(true);
}
// match failed
result = null;
return(false);
}
public static void Match <T>(this ICodeMatchingService service, ICultureExpression requestedCulture, T codedItem) where T : ICodedItem
{
HttpContext httpContext = service.HttpContext;
IServiceProvider services = httpContext.RequestServices;
ICultureOption cultureOption = services.GetRequiredService <ICultureOption>();
service.Match(requestedCulture, cultureOption.DefaultCulture, codedItem);
}
public static string Match(this ICodeMatchingService service, ICultureExpression requestedCulture, string code, string defaultName)
{
HttpContext httpContext = service.HttpContext;
IServiceProvider services = httpContext.RequestServices;
ICultureOption cultureOption = services.GetRequiredService <ICultureOption>();
return(service.Match(requestedCulture, cultureOption.DefaultCulture, code, defaultName));
}
public static void Match <T>(this ICodeMatchingService service, IEnumerable <T> codedItems) where T : ICodedItem
{
HttpContext httpContext = service.HttpContext;
IServiceProvider services = httpContext.RequestServices;
ICultureOption cultureOption = services.GetRequiredService <ICultureOption>();
ICultureContext cultureContext = services.GetRequiredService <ICultureContext>();
service.Match(cultureContext.CurrentCulture, cultureOption.DefaultCulture, codedItems);
}
public CodeMatchingCache(
int cultureCacheCapacity,
int perCultureCapacity,
ICodeMatchingOption matchingOption,
ICultureOption cultureOption,
ICultureFileCache cultureFileCache)
{
this.cultureCache = new Cache <string, CulturePage>(cultureCacheCapacity);
this.perCultureCapacity = perCultureCapacity;
this.matchingOption = matchingOption;
this.cultureOption = cultureOption;
this.cultureFileCache = cultureFileCache;
}
public static bool TryFindFile(
string directory,
string fileName,
string extension,
ICultureExpression requestedCulture,
HttpContext httpContext,
out IFileCultureInfo result)
{
IHostingEnvironment env = httpContext.RequestServices.GetRequiredService <IHostingEnvironment>();
ICultureOption option = httpContext.RequestServices.GetRequiredService <ICultureOption>();
return(TryFindFile(directory, fileName, extension, requestedCulture, env, option, out result));
}
public static bool IsCultureSupported(this ICultureOption cultureOption, ICultureExpression culture, out ICultureExpression supportedCulture)
{
ICultureExpression result;
if (culture.IsAllRegion)
{
result = cultureOption.SupportedCultures.FirstOrDefault(exp => exp.Language.Equals(culture.Language));
supportedCulture = result;
return(supportedCulture != null);
}
result = cultureOption.SupportedCultures.FirstOrDefault(exp => exp.Language.Equals(culture.Language) && exp.Region.Equals(culture.Region));
supportedCulture = result;
return(supportedCulture != null);
}
public static bool IsCultureSupported(this ICultureOption cultureOption, ICultureExpression culture)
{
if (culture.IsAllRegion)
{
return(cultureOption.SupportedCultures.Any(exp => exp.Language.Equals(culture.Language)));
}
return(cultureOption.SupportedCultures.Any(exp =>
{
if (exp.IsAllRegion)
{
return exp.Language.Equals(culture.Language);
}
return exp.Language.Equals(culture.Language) && exp.Region.Equals(culture.Region);
}));
}
public static IServiceCollection AddCodeMatching(
this IServiceCollection services,
string resourceDirectory = "/Strings",
bool isCaseSensitive = false,
int culturePageCacheSize = 100,
int cultureCacheSize = 20)
{
services.AddSingleton <ICodeMatchingOption>(new CodeMatchingOption(resourceDirectory, isCaseSensitive));
services.AddSingleton <ICodeMatchingCache>(provider =>
{
ICodeMatchingOption option = provider.GetRequiredService <ICodeMatchingOption>();
ICultureOption cultureOption = provider.GetRequiredService <ICultureOption>();
ICultureFileCache cultureFileCache = provider.GetRequiredService <ICultureFileCache>();
return(new CodeMatchingCache(cultureCacheSize, culturePageCacheSize, option, cultureOption, cultureFileCache));
});
services.AddScoped <ICodeMatchingService, CodeMatchingService>();
return(services);
}
public override ViewEngineResult FindView(ActionContext actionContext, ViewResult viewResult)
{
string viewName = viewResult.ViewName;
if (viewName == null)
{
viewName = GetActionName(actionContext);
}
if (viewName == null)
{
return(base.FindView(actionContext, viewResult));
}
string controllerName;
if (!actionContext.ActionDescriptor.RouteValues.TryGetValue(ControllerNameKey, out controllerName) ||
string.IsNullOrEmpty(controllerName))
{
controllerName = "";
}
string directory = Path.Combine("Views", controllerName);
HttpContext httpContext = actionContext.HttpContext;
IServiceProvider provider = httpContext.RequestServices;
ICultureOption cultureOption = provider.GetRequiredService <ICultureOption>();
ICultureContext cultureContext = provider.GetRequiredService <ICultureContext>();
CultureMatchingViewResult viewFindResult = (CultureMatchingViewResult)viewResult;
ICultureFileCache fileCache = provider.GetRequiredService <ICultureFileCache>();
IFileCultureInfo fileCultureInfo = fileCache.Get(viewFindResult.RequestedCulture, directory, viewName, "cshtml");
if (fileCultureInfo != null)
{
httpContext.RequestServices.GetRequiredService <ILocalizedViewRenderContextAccessor>().Context = new LocalizedViewRenderContext(viewFindResult.RequestedCulture, fileCultureInfo.Culture, cultureContext.UrlCultureSpecifier);
string relativePath = fileCultureInfo.RelativePath.Substring(0, fileCultureInfo.RelativePath.Length - 7); // 7 == ".cshtml".Length
relativePath = relativePath.Substring(directory.Length + 1);
viewResult.ViewName = relativePath;
return(base.FindView(actionContext, viewResult));
}
else
{
httpContext.RequestServices.GetRequiredService <ILocalizedViewRenderContextAccessor>().Context = new LocalizedViewRenderContext(viewFindResult.RequestedCulture, null, cultureContext.UrlCultureSpecifier);
return(base.FindView(actionContext, viewResult));
}
}
internal IFileCultureInfo Get(string directory, string name, string extension, IHostingEnvironment env, ICultureOption cultureOption)
{
string resourceKey = $"{directory}/{name}.?.{extension}";
return(cache.Get(resourceKey, key =>
{
if (ResourceRequestHelper.TryFindFile(directory, name, extension, culture, env, cultureOption, out IFileCultureInfo result))
{
return RetrivationResult <IFileCultureInfo> .Create(result);
}
return RetrivationResult <IFileCultureInfo> .Create(null);
}));
}
