.NET 6 中常用组件的配置及使用记录
已收录 9430

软件架构

分为模型层，服务层，接口层来做测试使用

如何使用 IConfiguration、Environment

直接在 builder 后的主机中使用。

builder.Configuration；
builder.Environment

如何使用 Swagger

.NET 6 自带模板已经默认添加 Swagger，直接使用即可。

builder.Services.AddSwaggerGen();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

如何添加 EFCore 到.NET 6 中

按照 EFCore 常规使用方法，申明表的 Entity 及 Dbcontext 后，在 program.cs 文件中添加

builder.Services.AddDbContext<Service.DataContext>(opt => {
    opt.UseSqlServer(builder.Configuration.GetConnectionString("Default"));
});

即可在其他地方注入使用 DataContext

使用 Sqlite 数据库，需要引用 Microsoft.EntityFrameworkCore.Sqlite，
并在添加服务时，改为

opt.UseSqlite(builder.Configuration.GetConnectionString("Default"));

包管理控制台数据库结构生成方法：
使用 add-migration 创建迁移
使用 update-database 更新数据结构

如何注入一个服务

builder.Services.AddScoped<UserIdentyService>();

如何定义全局的 using 引用

在根目录下新建一个 cs 文件，比如 Globalusing.cs，在里面添加你的全局引用，和常规引用不同的是，在 using 前面添加 global

global using Service;
global using Entity;
global using Entity.Dto;

如何使用 Autofac

添加 Nuget 引用

Autofac.Extensions.DependencyInjection

program.cs 文件添加 autofac 的使用和注入配置

builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(builder =>
 {
     Assembly assembly = Assembly.Load("Service.dll");
     builder.RegisterAssemblyTypes(assembly)
            //.AsImplementedInterfaces()// 无接口的注入方式
            .InstancePerDependency();
 });

此时即可构造函数注入使用。

如何使用 Log4Net

添加引用

Microsoft.Extensions.Logging.Log4Net.AspNetCore

新建配置文件 log4net.config；
添加 service 配置

//注入 Log4Net
builder.Services.AddLogging(cfg =>
{
    //默认的配置文件路径是在根目录，且文件名为 log4net.config
    //cfg.AddLog4Net();
    //如果文件路径或名称有变化，需要重新设置其路径或名称
    //比如在项目根目录下创建一个名为 config 的文件夹，将 log4net.config 文件移入其中，并改名为 log4net.config
    //则需要使用下面的代码来进行配置
    cfg.AddLog4Net(new Log4NetProviderOptions()
    {
        Log4NetConfigFileName = "config/log4net.config",
        Watch = true
    });
});

即可在需要的地方定义使用

_logger = LogManager.GetLogger(typeof(UserController));

如何使用全局异常过滤器

首先新建 GlobalExceptionFilter 全局异常过滤器，继承于 ExceptionFilter ，用于接收处理抛出的异常

public class GlobalExceptionFilter : IExceptionFilter
{
    readonly IWebHostEnvironment hostEnvironment;
    readonly ILog logger;
    public GlobalExceptionFilter(IWebHostEnvironment _hostEnvironment)
    {
        this.hostEnvironment = _hostEnvironment;
        this.logger = LogManager.GetLogger(typeof(GlobalExceptionFilter));
    }
    public void OnException(ExceptionContext context)
    {
        if (!context.ExceptionHandled)//如果异常没有处理
        {
            var result = new ApiResult
            {
                Code = 500,
                IsSuccess = false,
                Message = "服务器发生未处理的异常"
            };

            if (hostEnvironment.IsDevelopment())
            {
                result.Message += "," + context.Exception.Message;
                result.Data = context.Exception.StackTrace;
            }

            logger.Error(result);

            context.Result = new JsonResult(result);
            context.ExceptionHandled = true;//异常已处理
        }
    }
}

然后在 Service 中添加全局异常过滤器

builder.Services.AddControllers(option =>
    {
        option.Filters.Add<GlobalExceptionFilter>();
    }
);

添加控制器方法完成测试

[HttpGet("exception")]
public ApiResult ExceptionAction()
{
    throw new NotImplementedException();
}

如何使用 Redis 做缓存

使用 StackExchange.Redis 作为缓存组件（其他组件类似的使用方式）。nuget 安装 StackExchange.Redis.Extensions.Core
首先，先建立一个类 RedisClient ，用于管理 redis 的连接和操作，再建立一个 RedisClientFactory 类，用于创建 redis 的连接；

public class RedisClient{...}
public class RedisClientFactory{...}

appsettings.json 中添加 redis 的配置

"RedisConfig": {
    "Redis_Default": {
      "Connection": "127.0.0.1:6379",
      "InstanceName": "Redis1:"
    },
    "Redis_6": {
      "Connection": "127.0.0.1:6379",
      "DefaultDatabase": 6,
      "InstanceName": "Redis2:"
    }
  }

service 中添加 redis 客户端的引用

//添加 redis 的使用
builder.Services.AddSingleton<RedisClient>(_=> RedisClientFactory.GetInstance(builder.Configuration));

一顿操作后，就可以在你想要使用 redis 的地方引用了

RedisClient redisClient
...
this.redisDb = redisClient.GetDatabase("Redis_Default");
redisDb.StringSet("clientId", "clientId", TimeSpan.FromSeconds(10));

要使用 redis 做分布式缓存，先引用 Microsoft.Extensions.Caching.StackExchangeRedis

//将 Redis 分布式缓存服务添加到服务中
builder.Services.AddStackExchangeRedisCache(options =>
    {
        //用于连接 Redis 的配置  Configuration.GetConnectionString("RedisConnectionString")读取配置信息的串
        options.Configuration = "Redis_6";// Configuration.GetConnectionString("RedisConnectionString");
        //Redis 实例名 RedisDistributedCache
        options.InstanceName = "RedisDistributedCache";
    });

 

如何添加使用定时任务组件

此处使用 Hangfire 定时任务组件，轻便，可持久化，还有面板。
引用 Hangfire 后，即可新增定时任务。

//启用 Hangfire 服务.
builder.Services.AddHangfire(x => x.UseStorage(new MemoryStorage()));
builder.Services.AddHangfireServer();

...

//启用 Hangfire 面板
app.UseHangfireDashboard();
//开启一个定时任务
RecurringJob.AddOrUpdate("test",() => Console.WriteLine("Recurring!"), Cron.Minutely());

 

访问 https://localhost:7219/hangfire 即可看到任务面板

如何使用业务锁锁住下单或者支付操作

首先，做这个事需要能先构建出一个锁出来，这个锁有个锁的标识 key，可以根据这个 key 判定 key 对应的锁是否存在，
这样的话，在某个用户支付或者下单减库存啥的时候，就可以按照这个 key 先上锁，后面有用户走其他渠道进行同样的操作的时候，就可以根据是否上锁了，来判断操作能否继续。

比如一个支付订单的业务，可以在手机上操作，也可以在电脑上操作，这个时候就可以给支付接口上锁，只要一个支付过程存在着，并且没有超时，那就不能在其他渠道进行操作。
我们上面已经使用了 redis，下面就用 redis 构建个锁来模拟这个操作,具体看代码：

/// <summary>
    /// 测试业务锁
    /// </summary>
    /// <returns></returns>
    [HttpGet("lockhandle")]
    public async Task<ApiResult> LockHandle(int userId)
    {
        var key = "user";
        var token = $"ID:{userId}";
        try
        {
            if (redisDb.LockTake(key, token, TimeSpan.FromSeconds(50)))
            {
                await Task.Delay(30 * 1000);
                return await Task.FromResult(ApiResult.Success($"ID:{userId} 获取到锁了，操作正常,connectId:{Request.HttpContext.Connection.Id}"));
            }
            else
            {
                return await Task.FromResult(ApiResult.Fail($"有正在操作的锁,connectId:{Request.HttpContext.Connection.Id}"));
            }
        }
        catch (Exception)
        {
            throw;
        }
        finally
        {
            redisDb.LockRelease(key, token);
        }
    }

如何配置跨域

此处主要记录全局跨域，不包括指定 api 跨域。先增加一个配置 “Cors”: “http:127.0.0.1:5001″，配置可以跨域的 url，也可以使用默认跨域配置。
host 配置以下服务,按需使用：

builder.Services.AddCors(delegate (CorsOptions options)
{
    options.AddPolicy("CorsPolicy", delegate (CorsPolicyBuilder corsBuilder)
    {
        //指定 url 跨域
        corsBuilder.WithOrigins(builder.Configuration.GetValue<string>("Cors").Split(','));
        //默认跨域
        corsBuilder.SetIsOriginAllowed((string _) => true).AllowAnyMethod().AllowAnyHeader()
            .AllowCredentials();
    });
});

如何使用 NewtonsoftJson

.NET6 默认的系列化库是内置的 System.Text.Json，使用中如果有诸多不熟悉的地方，那肯定是想换回 NewtonsoftJson，需要 nuget 引用 Microsoft.AspNetCore.Mvc.NewtonsoftJson 来配置使用，
常用配置包括日期格式、大小写规则、循环引用配置。。。等，下面是一个配置

builder.Services.AddControllers(option =>
    {
        option.Filters.Add<GlobalExceptionFilter>();
    }
).AddNewtonsoftJson(options =>
{
    options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); //序列化时 key 为驼峰样式
    options.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Local;
    options.SerializerSettings.DateFormatString = "yyyy-MM-dd HH:mm:ss";
    options.SerializerSettings.ReferenceLoopHandling =  ReferenceLoopHandling.Ignore;//忽略循环引用
});

如何使用 SignalR

首先添加一个 ChatHub 作为 交互中心处理器

public class ChatHub : Hub
    {
        public async Task SendMessage(string user, string message)
        {
            await Clients.All.SendAsync("ReceiveMessage", user, message);
        }
    }

在主机中使用服务

builder.Services.AddSignalR();
...
app.UseEndpoints(endpoints =>
{
    endpoints.MapHub<ChatHub>("/chatHub");
});

如何使用 Dapper

Dapper 是大家常用的一个数据库连接扩展组件，下面介绍下，如何使用常规扩展，来在.net Core 中使用 Dapper。
首先，建立一个 DbComponent ，来获取由 .netCore 提供的 Configuration 配置文件，并用 DbProviderFactories 工厂，创建数据库连接，此类只管创建连接，又其他使用类进行销毁。

/// <summary>
/// 创建连接处理
/// </summary>
public class DbComponent
{
    /// 数据库连接配置
    private static ConnectionStringSettings connectionSetting;

    public static void InitDapper(ConnectionStringSettings connectionStringSettings)
    {
        connectionSetting = connectionStringSettings;
    }

    //通过工厂模式创建 Connection 连接 此连接已打开
    public static IDbConnection GetConnection()
    {
        get {
            var cnnection = DbProviderFactories.GetFactory(connectionSetting.ProviderName).CreateConnection();
            if (cnnection == null)
                throw new Exception("数据库链接获取失败!");
            cnnection.ConnectionString = connectionSetting.ConnectionString;
            cnnection.Open();
            return cnnection;
        }
    }
}

使用前，需要在 program 中初始化一下组件

/// <summary>
/// 初始化 Dapper 组件
/// </summary>
DbProviderFactories.RegisterFactory("Microsoft.Data.Sqlite", Microsoft.Data.Sqlite.SqliteFactory.Instance);
DbComponent.InitDapper(new System.Configuration.ConnectionStringSettings
{
    ConnectionString = builder.Configuration.GetConnectionString("Default"),
    ProviderName = "Microsoft.Data.Sqlite"
});

程序启动后，就可以在需要的地方使用

/// <summary>
/// 初始化 Dapper 组件
/// </summary>
DbProviderFactories.RegisterFactory("Microsoft.Data.Sqlite", Microsoft.Data.Sqlite.SqliteFactory.Instance);
DbComponent.InitDapper(new System.Configuration.ConnectionStringSettings
{
    ConnectionString = builder.Configuration.GetConnectionString("Default"),
    ProviderName = "Microsoft.Data.Sqlite"
});

如何添加自定义配置文件

有时候我们不想把配置全部放在 appsettings.json ，我们想自己建立一个文件夹来存储其他配置文件，比如 config/…json 之类的，咋整呢，
我们新建个文件夹 config，下面建立一个配置文件 app.json，里面存几个配置以便验证。

使用前添加如下代码即可

/// <summary>
/// 初始化 Dapper 组件
/// </summary>
DbProviderFactories.RegisterFactory("Microsoft.Data.Sqlite", Microsoft.Data.Sqlite.SqliteFactory.Instance);
DbComponent.InitDapper(new System.Configuration.ConnectionStringSettings
{
    ConnectionString = builder.Configuration.GetConnectionString("Default"),
    ProviderName = "Microsoft.Data.Sqlite"
});

如何简单上传文件

上传文件是每个 api 框架都会实现的功能，我们先实现一个简单的文件上传。
首先做个配置文件，存储上传的文件存储位置、大小及格式限制等的配置

public class UploadConfig
{
    /// <summary>
    /// 最大值
    /// </summary>
    public int MaxSize { get; set; } = 1024 * 1024 * 1024;
    /// <summary>
    /// 存储路径
    /// </summary>
    public string UploadDir { get; set; } = @"D://Upload";
    /// <summary>
    /// 站点名称
    /// </summary>
    public string WebSite { get; set; }
}

添加测试 action,完成文件上传，并返回文件访问路径

/// <summary>
/// 上传文件测试
/// </summary>
/// <param name="files"></param>
/// <returns></returns>
[HttpPost("upload")]
public async Task<ApiResult> Upload([FromForm(Name ="file")] List<IFormFile> files)
{
    var config = configuration.GetSection("UploadConfig").Get<UploadConfig>();
    if (files.Count == 0)
    {
        return ApiResult.Fail("没有需要上传的文件");
    }
    var dir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, config.UploadDir);
    
    if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);

    //验证大小或者格式之类
    foreach (var file in files)
    {
        var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName;
        var fileSize = file.Length;
        if (fileSize > config.MaxSize)
        {
            return ApiResult.Fail($"{fileName}文件过大");
        }
    }
    //存储文件
    var result = new List<string>();
    foreach (var file in files)
    {
        var fileName = file.FileName;
        using (var stream = System.IO.File.Create(Path.Combine(dir, fileName)))
        {
            await file.CopyToAsync(stream);
        }
        result.Add(string.Join('/',config.WebSite,"upload/view" fileName));
    }
    return ApiResult.Success(result);
}

上述文件访问路径需要配置静态目录来进行访问

//启动 www 静态目录
app.UseStaticFiles();
//启动上传文件目录
app.UseStaticFiles(new StaticFileOptions { 
    FileProvider =  new PhysicalFileProvider(builder.Configuration.GetValue<string>("UploadConfig:UploadDir")),
    RequestPath = "/upload/view"
});

至此，文件上传及访问已添加完成。

来源：https://www.cnblogs.com/Start201505/p/15713345.html

© 版权声明
博主的文章没有高度、深度和广度，只是凑字数。利用读书、参考、引用、抄袭、复制和粘贴等多种方式打造成自己的纯镀 24k 文章！如若有侵权，请联系博主删除。

☆ END ☆
程序开发
# .NET6# 常用组件
喜欢就点个赞吧
点赞0 分享
相关推荐
图片正在生成中，请稍后...