造轮子之多语言管理

轮子,语言,管理 · 浏览次数 : 0

小编点评

**代码描述** * `LocalizationManageController` 是一个控制器，用于管理多语言。 * `_localizationManageAppService` 是一个服务，用于获取和创建地区多语言。 * `GetCulture` 获取地区多语言详情。 * `CreateCulture` 创建地区多语言。 * `DeleteCulture` 删除地区多语言。 * `GetCulturePageList` 获取地区多语言资源列表。 * `CreateResource` 创建地区多语言资源。 * `UpdateResource` 更新地区多语言资源。 * `DeleteResource` 删除地区多语言资源。 * `GetResources` 获取地区多语言资源列表。 **主要方法** * `GetCulture` 获取地区多语言详情。 * `CreateCulture` 创建地区多语言。 * `DeleteCulture` 删除地区多语言。 * `GetCulturePageList` 获取地区多语言资源列表。 * `CreateResource` 创建地区多语言资源。 * `UpdateResource` 更新地区多语言资源。 * `DeleteResource` 删除地区多语言资源。 * `GetResources` 获取地区多语言资源列表。 **其他** * `L` 是一个 IStringLocalizer 实例。 * `启用服务测试一下。`

正文

多语言也是我们经常能用到的东西，asp.net core中默认支持了多语言，可以使用.resx资源文件来管理多语言配置。
但是在修改资源文件后，我们的应用服务无法及时更新，属实麻烦一些。我们可以通过扩展IStringLocalizer，实现我们想要的多语言配置方式，比如Json配置，PO 文件配置，EF数据库配置等等。
这里我们选用数据库配置的方式，直接查询数据库的多语言配置进行转换。

创建表实体

多语言管理只需要两个表结构，一个是多语言国家表，一个是多语言资源表。两者是一对多关系。

namespace Wheel.Domain.Localization
{
    public class LocalizationCulture : IEntity<int>
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public virtual List<LocalizationResource> Resources { get; set; }
    }
}

namespace Wheel.Domain.Localization
{
    public class LocalizationResource : IEntity<int>
    {
        public int Id { get; set; }
        public string Key { get; set; }
        public string Value { get; set; }
        public virtual int CultureId { get; set; }
        public virtual LocalizationCulture Culture { get; set; }
    }
}

修改DbContext

添加DbSet和配置表结构：

#region Localization
public DbSet<LocalizationCulture> Cultures { get; set; }
public DbSet<LocalizationResource> Resources { get; set; }
#endregion

protected override void OnModelCreating(ModelBuilder builder)
{
    base.OnModelCreating(builder);

    ConfigureIdentity(builder);
    ConfigureLocalization(builder);
    ConfigurePermissionGrants(builder);
}
void ConfigureLocalization(ModelBuilder builder)
{
    builder.Entity<LocalizationCulture>(b =>
    {
        b.Property(a => a.Id).ValueGeneratedOnAdd();
        b.ToTable("LocalizationCulture"); 
        b.Property(a => a.Name).HasMaxLength(32);
        b.HasMany(a => a.Resources);
    });
    builder.Entity<LocalizationResource>(b =>
    {
        b.Property(a => a.Id).ValueGeneratedOnAdd();
        b.ToTable("LocalizationResource");
        b.HasOne(a => a.Culture);
        b.HasIndex(a => a.CultureId);
        b.Property(a => a.Key).HasMaxLength(256);
        b.Property(a => a.Value).HasMaxLength(1024);
    });
}

然后进行数据库迁移即可生成数据库表结构。

实现EF多语言

这里我们需要实现一下EFStringLocalizerFactory和EFStringLocalizer，使用EFStringLocalizerFactory来创建EFStringLocalizer。

namespace Wheel.Localization
{
    public class EFStringLocalizerFactory : IStringLocalizerFactory, ISingletonDependency
    {
        IServiceProvider _serviceProvider;
        public EFStringLocalizerFactory(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }

        public IStringLocalizer Create(Type resourceSource)
        {
            var scope = _serviceProvider.CreateScope();
            var db = scope.ServiceProvider.GetRequiredService<WheelDbContext>();
            var cahce = scope.ServiceProvider.GetRequiredService<IMemoryCache>();
            return new EFStringLocalizer(db, cahce);
        }

        public IStringLocalizer Create(string baseName, string location)
        {
            var scope = _serviceProvider.CreateScope();
            var db = scope.ServiceProvider.GetRequiredService<WheelDbContext>();
            var cahce = scope.ServiceProvider.GetRequiredService<IMemoryCache>();
            return new EFStringLocalizer(db, cahce);
        }
    }
}


namespace Wheel.Localization
{
    public class EFStringLocalizer : IStringLocalizer
    {
        private readonly WheelDbContext _db;
        private readonly IMemoryCache _memoryCache;
        public EFStringLocalizer(WheelDbContext db, IMemoryCache memoryCache)
        {
            _db = db;
            _memoryCache = memoryCache;
        }

        public LocalizedString this[string name]
        {
            get
            {
                var value = GetString(name);
                return new LocalizedString(name, value ?? name, resourceNotFound: value == null);
            }
        }

        public LocalizedString this[string name, params object[] arguments]
        {
            get
            {
                var format = GetString(name);
                var value = string.Format(format ?? name, arguments);
                return new LocalizedString(name, value, resourceNotFound: format == null);
            }
        }

        public IStringLocalizer WithCulture(CultureInfo culture)
        {
            CultureInfo.DefaultThreadCurrentCulture = culture;
            return new EFStringLocalizer(_db, _memoryCache);
        }

        public IEnumerable<LocalizedString> GetAllStrings(bool includeAncestorCultures)
        {
            return _db.Resources
                .Include(r => r.Culture)
                .Where(r => r.Culture.Name == CultureInfo.CurrentCulture.Name)
                .Select(r => new LocalizedString(r.Key, r.Value, r.Value == null));
        }

        private string? GetString(string name)
        {
            if (_memoryCache.TryGetValue<string>($"{CultureInfo.CurrentCulture.Name}:{name}", out var value))
            {
                return value;
            }
            else
            {
                value = _db.Resources
                .Include(r => r.Culture)
                .Where(r => r.Culture.Name == CultureInfo.CurrentCulture.Name)
                .FirstOrDefault(r => r.Key == name)?.Value;
                if (!string.IsNullOrWhiteSpace(value))
                {
                    _memoryCache.Set($"{CultureInfo.CurrentCulture.Name}:{name}", value, TimeSpan.FromMinutes(1));
                }
                return value;
            }
        }
    }

    public class EFStringLocalizer<T> : IStringLocalizer<T>
    {
        private readonly WheelDbContext _db;
        private readonly IMemoryCache _memoryCache;
        public EFStringLocalizer(WheelDbContext db, IMemoryCache memoryCache)
        {
            _db = db;
            _memoryCache = memoryCache;
        }

        public LocalizedString this[string name]
        {
            get
            {
                var value = GetString(name);
                return new LocalizedString(name, value ?? name, resourceNotFound: value == null);
            }
        }

        public LocalizedString this[string name, params object[] arguments]
        {
            get
            {
                var format = GetString(name);
                var value = string.Format(format ?? name, arguments);
                return new LocalizedString(name, value, resourceNotFound: format == null);
            }
        }

        public IStringLocalizer WithCulture(CultureInfo culture)
        {
            CultureInfo.DefaultThreadCurrentCulture = culture;
            return new EFStringLocalizer(_db, _memoryCache);
        }

        public IEnumerable<LocalizedString> GetAllStrings(bool includeAncestorCultures)
        {
            return _db.Resources
                .Include(r => r.Culture)
                .Where(r => r.Culture.Name == CultureInfo.CurrentCulture.Name)
                .Select(r => new LocalizedString(r.Key, r.Value, true));
        }

        private string? GetString(string name)
        {
            if (_memoryCache.TryGetValue<string>($"{CultureInfo.CurrentCulture.Name}:{name}", out var value))
            {
                return value;
            }
            else
            {
                value = _db.Resources
                .Include(r => r.Culture)
                .Where(r => r.Culture.Name == CultureInfo.CurrentCulture.Name)
                .FirstOrDefault(r => r.Key == name)?.Value;
                if (!string.IsNullOrWhiteSpace(value))
                {
                    _memoryCache.Set($"{CultureInfo.CurrentCulture.Name}:{name}", value, TimeSpan.FromMinutes(1));
                }
                return value;
            }
        }
    }
}

这里的GetString方法，我们先通过缓存查询多语言内容，若查询不到再进数据库查询，减少数据库的并发量。
多语言国家编码直接使用CultureInfo.CurrentCulture.Name获取。无需传参配置。

启用多语言

再Program中添加多语言代码：

builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");


app.UseRequestLocalization(new RequestLocalizationOptions
{
    ApplyCurrentCultureToResponseHeaders = true,
    DefaultRequestCulture = new RequestCulture("zh-CN"),
    SupportedCultures = new List<CultureInfo>
            {
                new CultureInfo("en"),
                new CultureInfo("zh-CN"),
            },
    SupportedUICultures = new List<CultureInfo>
            {
                new CultureInfo("en"),
                new CultureInfo("zh-CN"),
            }
});

这里配置默认语言是中文，同时支持英文和中文两种。

多语言管理API实现

接下来我们实现LocalizationManage
ILocalizationManageAppService:

namespace Wheel.Services.LocalizationManage
{
    public interface ILocalizationManageAppService : ITransientDependency
    {
        Task<R<LocalizationCultureDto>> GetLocalizationCultureAsync(int id);
        Task<Page<LocalizationCultureDto>> GetLocalizationCulturePageListAsync(PageRequest input);
        Task<R<LocalizationCultureDto>> CreateLocalizationCultureAsync(CreateLocalizationCultureDto input);
        Task<R> DeleteLocalizationCultureAsync(int id);
        Task<R<LocalizationResourceDto>> CreateLocalizationResourceAsync(CreateLocalizationResourceDto input);
        Task<R> UpdateLocalizationResourceAsync(UpdateLocalizationResourceDto input);
        Task<R> DeleteLocalizationResourceAsync(int id);
    }
}

LocalizationManageAppService:


namespace Wheel.Services.LocalizationManage
{
    /// <summary>
    /// 多语言管理
    /// </summary>
    public class LocalizationManageAppService : WheelServiceBase, ILocalizationManageAppService
    {
        private readonly IBasicRepository<LocalizationCulture, int> _localizationCultureRepository;
        private readonly IBasicRepository<LocalizationResource, int> _localizationResourceRepository;

        public LocalizationManageAppService(IBasicRepository<LocalizationCulture, int> localizationCultureRepository, IBasicRepository<LocalizationResource, int> localizationResourceRepository)
        {
            _localizationCultureRepository = localizationCultureRepository;
            _localizationResourceRepository = localizationResourceRepository;
        }
        /// <summary>
        /// 获取地区多语言详情
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<R<LocalizationCultureDto>> GetLocalizationCultureAsync(int id)
        {
            var entity = await _localizationCultureRepository.FindAsync(id);

            return new R<LocalizationCultureDto>(Mapper.Map<LocalizationCultureDto>(entity));
        }
        /// <summary>
        /// 分页获取地区多语言列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<Page<LocalizationCultureDto>> GetLocalizationCulturePageListAsync(PageRequest input)
        {
            var (entities, total) = await _localizationCultureRepository
                .GetPageListAsync(a => true,
                (input.PageIndex - 1) * input.PageSize,
                input.PageSize,
                propertySelectors: a => a.Resources
                );

            return new Page<LocalizationCultureDto>(Mapper.Map<List<LocalizationCultureDto>>(entities), total);
        }
        /// <summary>
        /// 创建地区多语言
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<R<LocalizationCultureDto>> CreateLocalizationCultureAsync(CreateLocalizationCultureDto input)
        {
            var entity = Mapper.Map<LocalizationCulture>(input);
            entity = await _localizationCultureRepository.InsertAsync(entity);
            await UnitOfWork.SaveChangesAsync();
            return new R<LocalizationCultureDto>(Mapper.Map<LocalizationCultureDto>(entity));
        }
        /// <summary>
        /// 删除地区多语言
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<R> DeleteLocalizationCultureAsync(int id)
        {
            await _localizationCultureRepository.DeleteAsync(id);
            await UnitOfWork.SaveChangesAsync();
            return new R();
        }
        /// <summary>
        /// 创建多语言资源
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<R<LocalizationResourceDto>> CreateLocalizationResourceAsync(CreateLocalizationResourceDto input)
        {
            var entity = Mapper.Map<LocalizationResource>(input);
            entity = await _localizationResourceRepository.InsertAsync(entity);
            await UnitOfWork.SaveChangesAsync();
            return new R<LocalizationResourceDto>(Mapper.Map<LocalizationResourceDto>(entity));
        }
        /// <summary>
        /// 修改多语言资源
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<R> UpdateLocalizationResourceAsync(UpdateLocalizationResourceDto input)
        {
            await _localizationResourceRepository.UpdateAsync(a => a.Id == input.Id,
                a => a.SetProperty(b => b.Key, b => input.Key).SetProperty(b => b.Value, b => input.Value));
            await UnitOfWork.SaveChangesAsync();
            return new R();
        }
        /// <summary>
        /// 删除多语言资源
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<R> DeleteLocalizationResourceAsync(int id)
        {
            await _localizationResourceRepository.DeleteAsync(id);
            await UnitOfWork.SaveChangesAsync();
            return new R();
        }
    }
}

这里包含了多语言的CURD的实现
LocalizationManageController:

namespace Wheel.Controllers
{
    /// <summary>
    /// 多语言管理
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    public class LocalizationManageController : WheelControllerBase
    {
        private readonly ILocalizationManageAppService _localizationManageAppService;

        public LocalizationManageController(ILocalizationManageAppService localizationManageAppService)
        {
            _localizationManageAppService = localizationManageAppService;
        }

        /// <summary>
        /// 获取地区多语言详情
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("Culture/{id}")]
        public async Task<R<LocalizationCultureDto>> GetCulture(int id)
        {
            return await _localizationManageAppService.GetLocalizationCultureAsync(id);
        }
        /// <summary>
        /// 创建地区多语言
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("Culture")]
        public async Task<R<LocalizationCultureDto>> CreateCulture(CreateLocalizationCultureDto input)
        {
            return await _localizationManageAppService.CreateLocalizationCultureAsync(input);
        }
        /// <summary>
        /// 删除地区多语言
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("Culture/{id}")]
        public async Task<R> DeleteCulture(int id)
        {
            return await _localizationManageAppService.DeleteLocalizationCultureAsync(id);
        }
        /// <summary>
        /// 分页获取地区多语言列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("Culture")]
        public async Task<Page<LocalizationCultureDto>> GetCulturePageList([FromQuery]PageRequest input)
        {
            return await _localizationManageAppService.GetLocalizationCulturePageListAsync(input);
        }
        /// <summary>
        /// 创建多语言资源
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("Resource")]
        public async Task<R<LocalizationResourceDto>> CreateResource(CreateLocalizationResourceDto input)
        {
            return await _localizationManageAppService.CreateLocalizationResourceAsync(input);
        }
        /// <summary>
        /// 修改多语言资源
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPut("Resource")]
        public async Task<R> UpdateResource(UpdateLocalizationResourceDto input)
        {
            return await _localizationManageAppService.UpdateLocalizationResourceAsync(input);
        }
        /// <summary>
        /// 删除多语言资源
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("Resource/{id}")]
        public async Task<R> DeleteResource(int id)
        {
            return await _localizationManageAppService.DeleteLocalizationResourceAsync(id);
        }
        /// <summary>
        /// 获取多语言资源列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("Resources")]
        [AllowAnonymous]
        public Task<R<Dictionary<string, string>>> GetResources()
        {
            var resources = L.GetAllStrings().ToDictionary(a=>a.Name, a=>a.Value);
            return Task.FromResult(new R<Dictionary<string, string>>(resources));
        }
    }
}

在控制器额外添加一个匿名访问的API，GetResources()用于客户端集成多语言配置。L是IStringLocalizer实例。

启用服务测试一下。
image.png
image.png
可以看到成功获取英文和中文的多语言列表。

就这样我们完成多语言管理的实现。

轮子仓库地址https://github.com/Wheel-Framework/Wheel
欢迎进群催更。

image.png

轮子 语言 管理

与造轮子之多语言管理相似的内容：

造轮子之多语言管理

多语言也是我们经常能用到的东西，asp.net core中默认支持了多语言，可以使用.resx资源文件来管理多语言配置。但是在修改资源文件后，我们的应用服务无法及时更新，属实麻烦一些。我们可以通过扩展IStringLocalizer，实现我们想要的多语言配置方式，比如Json配置，PO 文件配置，E

轮子 语言 管理
0
我为什么还要造一个前端轮子？

一、原因 现在市面上有很多为前端开发的框架、模板。为什么我们还要再做一个呢，究其原因，因为这些框架和模板更多的基于技术层面提供了快捷方便的实现方法；但却缺少具体业务层面的实现。因此，结合自身需求，将各种系统常用的功能和页面进行归纳总结，实现了一套更贴近实际业务的前端框架，框架中提供了一系列实际的业务

0
造轮子之消息实时推送

前面我们的EventBus已经弄好了，那么接下来通过EventBus来实现我们的消息推送就是自然而然的事情了。说到消息推送，很多人肯定会想到Websocket，既然我们使用Asp.net core，那么SignalR肯定是我们的首选。接下来就用SignalR来实现我们的消息实时推送。 Notific

轮子 消息 实时 推送
72
造轮子之EventBus

前面基础管理的功能基本开发完了，接下来我们来优化一下开发功能，来添加EventBus功能。EventBus也是我们使用场景非常广的东西。这里我会实现一个本地的EventBus以及分布式的EventBus。分别使用MediatR和Cap来实现。 现在简单介绍一下这两者：MediatR是一个轻量级的中介

轮子 eventbus
52
造轮子之菜单管理

前面完成了基础管理的相关API，接下来就得做一个菜单管理了，用于对接管理后台前端界面。 设计菜单结构 菜单是一个多级结构，所以我们得设计一个树形的。包含自己上级和下级的属性。同时预留Permission用于做可选的权限限制。 namespace Wheel.Domain.Menus { ///

轮子 菜单 管理
34
造轮子之权限管理

上文已经完成了自定义授权策略，那么接下来就得完善我们的权限管理了。不然没有数据，如何鉴权~ 表设计 创建我们的表实体类： namespace Wheel.Domain.Permissions { public class PermissionGrant : Entity { public

轮子 权限 管理
58
造轮子之自定义授权策略

前面我们已经弄好了用户角色这块内容，接下来就是我们的授权策略。在asp.net core中提供了自定义的授权策略方案，我们可以按照需求自定义我们的权限过滤。这里我的想法是，不需要在每个Controller或者Action打上AuthorizeAttribute，自动根据ControllerName和

轮子 自定义 授权 策略
33
造轮子之asp.net core identity

在前面我们完成了应用最基础的功能支持以及数据库配置，接下来就是我们的用户角色登录等功能了，在asp.net core中原生Identity可以让我们快速完成这个功能的开发，在.NET8中，asp.net core identity支持了WebApi的注册登录。这让我们在WebApi中可以更爽快的使用

轮子 asp net core
74
造轮子之ORM集成

Dotnet的ORM千千万，还是喜欢用EF CORE 前面一些基础完成的差不多了，接下来可以集成数据库了，官方出品的ORM还是比较香。所以接下来就是来集成EF CORE。 安装包 首先我们需要安装一下EF CORE的NUGET包，有如下几个： Microsoft.EntityFrameworkCor

轮子 orm 集成
16
动手造轮子自己实现人工智能神经网络(ANN)，解决鸢尾花分类问题Golang1.18实现

人工智能神经网络（ Artificial Neural Network，又称为ANN）是一种由人工神经元组成的网络结构，神经网络结构是所有机器学习的基本结构，换句话说，无论是深度学习还是强化学习都是基于神经网络结构进行构建。关于人工神经元，请参见：人工智能机器学习底层原理剖析,人造神经元,您一定能看

动手 轮子 自己 实现
316
# 热门排行
微软 New Bing AI 申请与使用保姆级教程（免魔法） ChatGPT API使用介绍 ChatGPT开发实战 一篇带你了解如何使用纯前端类Excel表格构建现金流量表 手把手教你玩转 Excel 数据透视表 为什么 C# 可能是最好的第一编程语言 .NET 入门到高级路线 提高工作效率的神器：基于前端表格实现Chrome Excel扩展插件 React + Springboot + Quartz，从0实现Excel报表自动化 用Echarts实现前端表格引用从属关系可视化
© PmDaddy. 2023 PmDaddy教程网 All rights reserved.