585 lines
26 KiB
C#
585 lines
26 KiB
C#
using System.Collections.Concurrent;
|
||
using System.Globalization;
|
||
using System.Text.Json;
|
||
using Microsoft.JSInterop;
|
||
using Microsoft.Extensions.Localization;
|
||
|
||
namespace Atomx.Admin.Client.Services
|
||
{
|
||
/// <summary>
|
||
/// 提供多语言 JSON 文件加载、缓存与运行时切换的实现。
|
||
/// - 在 Server 环境：尝试通过反射访问 IWebHostEnvironment 的 webroot，从文件系统读取 {culture}.json 文件。
|
||
/// - 在 WASM 环境：使用注入的 HttpClient 从 /localization/{culture}.json 下载并解析。
|
||
/// 同时在切换语言时写入 Cookie 并设置页面 HTML lang 属性。
|
||
/// </summary>
|
||
public interface ILocalizationProvider
|
||
{
|
||
string CurrentCulture { get; }
|
||
string? GetString(string key);
|
||
Task SetCultureAsync(string cultureShortOrFull);
|
||
Task InitializeAsync();
|
||
/// <summary>
|
||
/// 保证指定文化的资源已被加载（异步）。供外部在需要时触发加载。
|
||
/// </summary>
|
||
Task LoadCultureAsync(string culture);
|
||
event EventHandler<string>? LanguageChanged;
|
||
}
|
||
|
||
public class LocalizationProvider : ILocalizationProvider
|
||
{
|
||
private readonly IServiceProvider _sp;
|
||
private readonly IHttpClientFactory? _httpClientFactory;
|
||
private readonly IJSRuntime? _jsRuntime;
|
||
private readonly ILogger<LocalizationProvider> _logger;
|
||
private readonly ILocalizationService _localizationService;
|
||
|
||
// 缓存：culture -> translations
|
||
// Use a static concurrent dictionary so files loaded during middleware/server prerender
|
||
// are visible to provider instances created later in the same request pipeline.
|
||
private static readonly ConcurrentDictionary<string, Dictionary<string, string>> _cache = new();
|
||
|
||
// 短码到完整 culture 的映射
|
||
private static readonly Dictionary<string, string> ShortToCulture = new(StringComparer.OrdinalIgnoreCase)
|
||
{
|
||
{ "zh", "zh-Hans" },
|
||
{ "en", "en-US" }
|
||
};
|
||
|
||
private string _currentCulture = "zh-Hans";
|
||
|
||
private const string CookieName = "atomx.culture";
|
||
|
||
public LocalizationProvider(IServiceProvider sp, IHttpClientFactory? httpClientFactory, IJSRuntime? jsRuntime, ILogger<LocalizationProvider> logger, ILocalizationService localizationService)
|
||
{
|
||
_sp = sp;
|
||
_httpClientFactory = httpClientFactory;
|
||
_jsRuntime = jsRuntime;
|
||
_logger = logger;
|
||
_localizationService = localizationService;
|
||
|
||
// 不在构造函数中进行 JS 相关同步 IO，但尝试根据线程 culture 设置初始值并归一化为完整 culture
|
||
try
|
||
{
|
||
var threadUi = CultureInfo.DefaultThreadCurrentUICulture ?? CultureInfo.CurrentUICulture;
|
||
if (!string.IsNullOrEmpty(threadUi?.Name))
|
||
{
|
||
_currentCulture = MapToFullCulture(threadUi!.Name);
|
||
_logger?.LogDebug("LocalizationProvider ctor detected thread UI culture: {Culture}", _currentCulture);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "LocalizationProvider ctor failed to read thread culture");
|
||
}
|
||
|
||
// 如果运行在 Server（IWebHostEnvironment 可用），且 JSRuntime 不可用（说明非浏览器），则同步从文件加载本地化文件
|
||
try
|
||
{
|
||
var envType = Type.GetType("Microsoft.AspNetCore.Hosting.IWebHostEnvironment, Microsoft.AspNetCore.Hosting.Abstractions")
|
||
?? Type.GetType("Microsoft.AspNetCore.Hosting.IWebHostEnvironment");
|
||
if (envType != null)
|
||
{
|
||
var env = _sp.GetService(envType);
|
||
if (env != null && _jsRuntime == null)
|
||
{
|
||
var webRootProp = envType.GetProperty("WebRootPath");
|
||
var contentRootProp = envType.GetProperty("ContentRootPath");
|
||
var webRoot = webRootProp?.GetValue(env) as string ?? Path.Combine(contentRootProp?.GetValue(env) as string ?? ".", "wwwroot");
|
||
var path = Path.Combine(webRoot ?? ".", "localization", _currentCulture + ".json");
|
||
if (File.Exists(path))
|
||
{
|
||
try
|
||
{
|
||
var json = File.ReadAllText(path);
|
||
var dict = JsonSerializer.Deserialize<Dictionary<string, string>>(json) ?? new Dictionary<string, string>();
|
||
_cache[_currentCulture] = dict;
|
||
_logger?.LogInformation("Loaded localization file for {Culture} from path {Path}, entries: {Count}", _currentCulture, path, dict.Count);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogWarning(ex, "Failed to read localization file synchronously: {Path}", path);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_logger?.LogDebug("Localization file not found at {Path}", path);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "Synchronous file load attempt failed in ctor");
|
||
}
|
||
}
|
||
|
||
public string CurrentCulture => _currentCulture;
|
||
|
||
public event EventHandler<string>? LanguageChanged;
|
||
|
||
public string? GetString(string key)
|
||
{
|
||
if (string.IsNullOrEmpty(key)) return null;
|
||
|
||
if (_cache.TryGetValue(_currentCulture, out var dict) && dict.TryGetValue(key, out var val))
|
||
{
|
||
return val;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
public async Task InitializeAsync()
|
||
{
|
||
_logger?.LogDebug("LocalizationProvider.InitializeAsync start. CurrentCulture={Culture}", _currentCulture);
|
||
|
||
string? urlFirstSegment = null;
|
||
|
||
try
|
||
{
|
||
if (_jsRuntime != null && OperatingSystem.IsBrowser())
|
||
{
|
||
var path = await _jsRuntime.InvokeAsync<string>("eval", "location.pathname");
|
||
_logger?.LogDebug("JS location.pathname='{Path}'", path);
|
||
if (!string.IsNullOrEmpty(path))
|
||
{
|
||
var trimmed = path.Trim('/');
|
||
if (!string.IsNullOrEmpty(trimmed))
|
||
{
|
||
var seg = trimmed.Split('/', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
|
||
urlFirstSegment = seg;
|
||
_logger?.LogDebug("Detected url first segment: {Segment}", urlFirstSegment);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "读取 location.pathname 失败");
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(urlFirstSegment) && ShortToCulture.TryGetValue(urlFirstSegment, out var mapped))
|
||
{
|
||
_logger?.LogDebug("URL short segment '{Seg}' mapped to culture '{Culture}'", urlFirstSegment, mapped);
|
||
await SetCultureInternalAsync(mapped, persistCookie: false);
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
if (_jsRuntime != null && OperatingSystem.IsBrowser())
|
||
{
|
||
var cookieVal = await _jsRuntime.InvokeAsync<string>("cookies.Read", CookieName);
|
||
_logger?.LogDebug("Cookie '{CookieName}'='{CookieVal}'", CookieName, cookieVal);
|
||
if (!string.IsNullOrEmpty(cookieVal))
|
||
{
|
||
if (ShortToCulture.TryGetValue(cookieVal, out var mappedFromCookie))
|
||
{
|
||
_logger?.LogDebug("Cookie short '{Cookie}' mapped to {Culture}", cookieVal, mappedFromCookie);
|
||
await SetCultureInternalAsync(mappedFromCookie, persistCookie: false);
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
// 如果 cookie 中是完整 culture（或其他形式），归一化后使用
|
||
await SetCultureInternalAsync(MapToFullCulture(cookieVal), persistCookie: false);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "读取 Cookie 失败");
|
||
}
|
||
|
||
try
|
||
{
|
||
if (_jsRuntime != null && OperatingSystem.IsBrowser())
|
||
{
|
||
var browserLang = await _jsRuntime.InvokeAsync<string>("getBrowserLanguage");
|
||
_logger?.LogDebug("Browser language: {BrowserLang}", browserLang);
|
||
if (!string.IsNullOrEmpty(browserLang))
|
||
{
|
||
var mappedFromBrowser = MapToFullCulture(browserLang);
|
||
_logger?.LogDebug("Browser mapped to {Culture}", mappedFromBrowser);
|
||
await SetCultureInternalAsync(mappedFromBrowser, persistCookie: false);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "读取浏览器语言失败");
|
||
}
|
||
|
||
// 最后确保加载当前 culture
|
||
_logger?.LogDebug("InitializeAsync falling back to current culture {Culture}", _currentCulture);
|
||
await EnsureCultureLoadedAsync(_currentCulture);
|
||
await SetCultureInternalAsync(_currentCulture, persistCookie: false);
|
||
}
|
||
|
||
public async Task SetCultureAsync(string cultureShortOrFull)
|
||
{
|
||
if (string.IsNullOrEmpty(cultureShortOrFull)) return;
|
||
if (ShortToCulture.TryGetValue(cultureShortOrFull, out var mapped))
|
||
{
|
||
await SetCultureInternalAsync(mapped, persistCookie: true);
|
||
}
|
||
else
|
||
{
|
||
await SetCultureInternalAsync(MapToFullCulture(cultureShortOrFull), persistCookie: true);
|
||
}
|
||
}
|
||
|
||
public Task LoadCultureAsync(string culture) => EnsureCultureLoadedAsync(MapToFullCulture(culture));
|
||
|
||
/// <summary>
|
||
/// Server-side synchronous culture set used during prerender to ensure translations
|
||
/// are available immediately. This method will attempt to load localization
|
||
/// JSON from the server's webroot synchronously and set thread cultures.
|
||
/// </summary>
|
||
public void SetCultureForServer(string cultureShortOrFull)
|
||
{
|
||
try
|
||
{
|
||
var cultureFull = MapToFullCulture(cultureShortOrFull);
|
||
if (string.IsNullOrEmpty(cultureFull)) return;
|
||
|
||
// set thread culture
|
||
try
|
||
{
|
||
var ci = new CultureInfo(cultureFull);
|
||
CultureInfo.DefaultThreadCurrentCulture = ci;
|
||
CultureInfo.DefaultThreadCurrentUICulture = ci;
|
||
_currentCulture = cultureFull;
|
||
}
|
||
catch { }
|
||
|
||
// try load from webroot synchronously via IWebHostEnvironment if available
|
||
try
|
||
{
|
||
var envType = Type.GetType("Microsoft.AspNetCore.Hosting.IWebHostEnvironment, Microsoft.AspNetCore.Hosting.Abstractions")
|
||
?? Type.GetType("Microsoft.AspNetCore.Hosting.IWebHostEnvironment");
|
||
if (envType != null)
|
||
{
|
||
var env = _sp.GetService(envType);
|
||
if (env != null)
|
||
{
|
||
var webRootProp = envType.GetProperty("WebRootPath");
|
||
var contentRootProp = envType.GetProperty("ContentRootPath");
|
||
var webRoot = webRootProp?.GetValue(env) as string ?? Path.Combine(contentRootProp?.GetValue(env) as string ?? ".", "wwwroot");
|
||
var path = Path.Combine(webRoot ?? ".", "localization", cultureFull + ".json");
|
||
if (File.Exists(path))
|
||
{
|
||
try
|
||
{
|
||
var json = File.ReadAllText(path);
|
||
var dict = JsonSerializer.Deserialize<Dictionary<string, string>>(json) ?? new Dictionary<string, string>();
|
||
_cache[cultureFull] = dict;
|
||
_logger?.LogInformation("(Server sync) Loaded localization file for {Culture} from path {Path}, entries: {Count}", cultureFull, path, dict.Count);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogWarning(ex, "(Server sync) Failed to read localization file synchronously: {Path}", path);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "SetCultureForServer failed to load file for {Culture}", cultureFull);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "SetCultureForServer encountered error");
|
||
}
|
||
}
|
||
|
||
private async Task SetCultureInternalAsync(string cultureFull, bool persistCookie)
|
||
{
|
||
//_logger?.LogDebug("设置内部文化异步开始: {Culture}, 持久化={Persist}", cultureFull, persistCookie);
|
||
await EnsureCultureLoadedAsync(cultureFull);
|
||
|
||
try
|
||
{
|
||
var ci = new CultureInfo(cultureFull);
|
||
CultureInfo.DefaultThreadCurrentCulture = ci;
|
||
CultureInfo.DefaultThreadCurrentUICulture = ci;
|
||
_currentCulture = cultureFull;
|
||
_localizationService.SetLanguage(ci);
|
||
_logger?.LogDebug("Culture set to {Culture}", cultureFull);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogWarning(ex, "设置 Culture 失败: {Culture}", cultureFull);
|
||
}
|
||
|
||
if (persistCookie && _jsRuntime != null)
|
||
{
|
||
try
|
||
{
|
||
var shortKey = ShortToCulture.FirstOrDefault(kv => string.Equals(kv.Value, cultureFull, StringComparison.OrdinalIgnoreCase)).Key ?? cultureFull;
|
||
await _jsRuntime.InvokeVoidAsync("cookies.Write", CookieName, shortKey, DateTime.UtcNow.AddYears(1).ToString("o"));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "写 Cookie 失败");
|
||
}
|
||
}
|
||
|
||
try
|
||
{
|
||
if (_jsRuntime != null)
|
||
{
|
||
await _jsRuntime.InvokeVoidAsync("setHtmlLang", cultureFull);
|
||
}
|
||
}
|
||
catch { }
|
||
|
||
LanguageChanged?.Invoke(this, cultureFull);
|
||
}
|
||
|
||
private async Task EnsureCultureLoadedAsync(string cultureFull)
|
||
{
|
||
// Normalize possible short codes (e.g. zh -> zh-Hans, en -> en-US) and variants (zh-CN -> zh-Hans)
|
||
cultureFull = MapToFullCulture(cultureFull);
|
||
|
||
if (string.IsNullOrEmpty(cultureFull)) return;
|
||
if (_cache.ContainsKey(cultureFull))
|
||
{
|
||
_logger?.LogDebug("EnsureCultureLoadedAsync: culture {Culture} already cached", cultureFull);
|
||
return;
|
||
}
|
||
|
||
// Prefer HttpClient when running in browser (WASM)
|
||
if (_jsRuntime != null && OperatingSystem.IsBrowser())
|
||
{
|
||
_logger?.LogInformation("EnsureCultureLoadedAsync: running in browser, will attempt HttpClient for {Culture}", cultureFull);
|
||
try
|
||
{
|
||
var http = _sp.GetService(typeof(HttpClient)) as HttpClient;
|
||
if (http == null && _httpClientFactory != null)
|
||
{
|
||
_logger?.LogDebug("HttpClient not found from service provider, using factory");
|
||
http = _httpClientFactory.CreateClient();
|
||
}
|
||
else
|
||
{
|
||
_logger?.LogDebug("HttpClient resolved from service provider: {HasClient}", http != null);
|
||
}
|
||
|
||
if (http != null)
|
||
{
|
||
var url = $"/localization/{cultureFull}.json";
|
||
Uri? requestUri = null;
|
||
|
||
// If HttpClient has a BaseAddress, use it. Otherwise, if running in browser, build absolute URI from location.origin
|
||
if (http.BaseAddress != null)
|
||
{
|
||
requestUri = new Uri(http.BaseAddress, url);
|
||
}
|
||
else if (_jsRuntime != null && OperatingSystem.IsBrowser())
|
||
{
|
||
try
|
||
{
|
||
var origin = await _jsRuntime.InvokeAsync<string>("eval", "location.origin");
|
||
if (!string.IsNullOrEmpty(origin))
|
||
{
|
||
// ensure no double slashes
|
||
requestUri = new Uri(new Uri(origin), url);
|
||
}
|
||
}
|
||
catch (Exception jsEx)
|
||
{
|
||
_logger?.LogDebug(jsEx, "Failed to get location.origin from JS");
|
||
}
|
||
}
|
||
|
||
if (requestUri != null)
|
||
{
|
||
_logger?.LogInformation("Downloading localization from {Url}", requestUri);
|
||
var txt = await http.GetStringAsync(requestUri);
|
||
var dict = JsonSerializer.Deserialize<Dictionary<string, string>>(txt) ?? new Dictionary<string, string>();
|
||
_cache[cultureFull] = dict;
|
||
_logger?.LogInformation("Loaded localization via HttpClient for {Culture}, entries: {Count}", cultureFull, dict.Count);
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
_logger?.LogWarning("HttpClient has no BaseAddress and JSRuntime unavailable to construct absolute URL; skipping HttpClient load for {Culture}", cultureFull);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_logger?.LogWarning("No HttpClient available to load localization for {Culture}", cultureFull);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "通过 HttpClient 加载本地化文件失败: {Culture}", cultureFull);
|
||
}
|
||
}
|
||
|
||
_logger?.LogDebug("EnsureCultureLoadedAsync trying filesystem for {Culture}", cultureFull);
|
||
// 尝试通过反射获取 IWebHostEnvironment（Server 时可用）
|
||
try
|
||
{
|
||
var envType = Type.GetType("Microsoft.AspNetCore.Hosting.IWebHostEnvironment, Microsoft.AspNetCore.Hosting.Abstractions")
|
||
?? Type.GetType("Microsoft.AspNetCore.Hosting.IWebHostEnvironment");
|
||
if (envType != null)
|
||
{
|
||
var env = _sp.GetService(envType);
|
||
if (env != null)
|
||
{
|
||
var webRootProp = envType.GetProperty("WebRootPath");
|
||
var contentRootProp = envType.GetProperty("ContentRootPath");
|
||
var webRoot = webRootProp?.GetValue(env) as string ?? Path.Combine(contentRootProp?.GetValue(env) as string ?? ".", "wwwroot");
|
||
var path = Path.Combine(webRoot ?? ".", "localization", cultureFull + ".json");
|
||
_logger?.LogDebug("Looking for localization file at {Path}", path);
|
||
if (File.Exists(path))
|
||
{
|
||
var json = await File.ReadAllTextAsync(path);
|
||
var dict = JsonSerializer.Deserialize<Dictionary<string, string>>(json) ?? new Dictionary<string, string>();
|
||
_cache[cultureFull] = dict;
|
||
_logger?.LogInformation("Loaded localization from file for {Culture}, entries: {Count}", cultureFull, dict.Count);
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
_logger?.LogDebug("Localization file not found at {Path}", path);
|
||
// Fallback: check build output wwwroot under AppContext.BaseDirectory
|
||
try
|
||
{
|
||
var alt = Path.Combine(AppContext.BaseDirectory ?? ".", "wwwroot", "localization", cultureFull + ".json");
|
||
_logger?.LogDebug("Looking for localization file at alternative path {AltPath}", alt);
|
||
if (File.Exists(alt))
|
||
{
|
||
var json2 = await File.ReadAllTextAsync(alt);
|
||
var dict2 = JsonSerializer.Deserialize<Dictionary<string, string>>(json2) ?? new Dictionary<string, string>();
|
||
_cache[cultureFull] = dict2;
|
||
_logger?.LogInformation("Loaded localization from alternative file path for {Culture}, entries: {Count}", cultureFull, dict2.Count);
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
_logger?.LogDebug("Localization file not found at alternative path {AltPath}", alt);
|
||
}
|
||
}
|
||
catch (Exception exAlt)
|
||
{
|
||
_logger?.LogDebug(exAlt, "Error while checking alternative localization path");
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_logger?.LogDebug("IWebHostEnvironment not resolved from service provider");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_logger?.LogDebug("IWebHostEnvironment type not found via reflection");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger?.LogDebug(ex, "从文件系统加载本地化文件失败: {Culture}", cultureFull);
|
||
}
|
||
|
||
_logger?.LogDebug("EnsureCultureLoadedAsync fallback to empty dict for {Culture}", cultureFull);
|
||
_cache[cultureFull] = new Dictionary<string, string>();
|
||
}
|
||
|
||
private string MapToFullCulture(string culture)
|
||
{
|
||
if (string.IsNullOrEmpty(culture)) return culture;
|
||
// direct mapping
|
||
if (ShortToCulture.TryGetValue(culture, out var mapped)) return mapped;
|
||
// consider prefix, e.g. zh-CN -> zh
|
||
var prefix = culture.Split('-', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
|
||
if (!string.IsNullOrEmpty(prefix) && ShortToCulture.TryGetValue(prefix, out var mapped2)) return mapped2;
|
||
return culture;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 基于 ILocalizationProvider 的 IStringLocalizer 实现：
|
||
/// 使用 JSON 文件中的键值，未找到返回 key 本身。
|
||
/// 名称改为 JsonStringLocalizer 避免与框架的 StringLocalizer 冲突。
|
||
/// </summary>
|
||
public class JsonStringLocalizer<T> : IStringLocalizer<T>
|
||
{
|
||
private readonly ILocalizationProvider _provider;
|
||
|
||
public JsonStringLocalizer(ILocalizationProvider provider)
|
||
{
|
||
_provider = provider;
|
||
}
|
||
|
||
public LocalizedString this[string name]
|
||
{
|
||
get
|
||
{
|
||
var value = _provider.GetString(name);
|
||
if (value == null)
|
||
{
|
||
// Avoid synchronous blocking during server prerender. Start background load and return key.
|
||
try
|
||
{
|
||
_ = _provider.LoadCultureAsync(_provider.CurrentCulture);
|
||
}
|
||
catch { }
|
||
}
|
||
|
||
var result = value ?? name;
|
||
return new LocalizedString(name, result, resourceNotFound: result == name);
|
||
}
|
||
}
|
||
|
||
public LocalizedString this[string name, params object[] arguments]
|
||
{
|
||
get
|
||
{
|
||
var fmt = _provider.GetString(name);
|
||
if (fmt == null)
|
||
{
|
||
try
|
||
{
|
||
_ = _provider.LoadCultureAsync(_provider.CurrentCulture);
|
||
}
|
||
catch { }
|
||
}
|
||
|
||
var format = fmt ?? name;
|
||
var value = string.Format(format, arguments);
|
||
return new LocalizedString(name, value, resourceNotFound: format == name);
|
||
}
|
||
}
|
||
|
||
public IEnumerable<LocalizedString> GetAllStrings(bool includeParentCultures)
|
||
{
|
||
var list = new List<LocalizedString>();
|
||
var providerType = _provider.GetType();
|
||
var currentProp = providerType.GetProperty("CurrentCulture");
|
||
var culture = currentProp?.GetValue(_provider) as string ?? string.Empty;
|
||
var cacheField = providerType.GetField("_cache", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
|
||
if (!string.IsNullOrEmpty(culture) && cacheField?.GetValue(_provider) is Dictionary<string, Dictionary<string, string>> cache && cache.TryGetValue(culture, out var dict))
|
||
{
|
||
foreach (var kv in dict)
|
||
{
|
||
list.Add(new LocalizedString(kv.Key, kv.Value, resourceNotFound: false));
|
||
}
|
||
}
|
||
return list;
|
||
}
|
||
|
||
public IStringLocalizer WithCulture(CultureInfo culture)
|
||
{
|
||
return this;
|
||
}
|
||
}
|
||
}
|