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); })); }