新版使用实例 基于NetCore 6.0

GlobalSystemErrorMiddleware 文件

using Dogegg.Abstractions.Domains;
using Dogegg.DomainService.IDomainService;
using JoreNoe.DB.Dapper;
using JoreNoe.Message;
using JoreNoe.Middleware;
using Newtonsoft.Json;

namespace Dogegg.API.Middlewares
{
    public class GlobalSystemErrorMiddleware : IJoreNoeGlobalErrorHandling
    {
    // Dapper 使用
        private readonly IRepository<GlobalRunningErrorHistory> GlobalRunningErrorHistoryRepository;
        private readonly IGlobalRunningSettingDomainService GlobalRunningSettingDomainService;
        //邮箱
        private IEmailMessageAPI EmailMessageAPI;
        private string[] SendMessageAccounts;
        public GlobalSystemErrorMiddleware(IRepository<GlobalRunningErrorHistory> GlobalRunningErrorHistoryRepository,
            IGlobalRunningSettingDomainService GlobalRunningSettingDomainService)
        {
            this.GlobalRunningErrorHistoryRepository = GlobalRunningErrorHistoryRepository;
            this.GlobalRunningSettingDomainService = GlobalRunningSettingDomainService;
        }
        public async Task GlobalErrorHandling(Exception Ex)
        {
            if (EmailMessageAPI == null)
            {
                var Single = await this.GlobalRunningSettingDomainService.Single(GlobalRunningSetting.Email).ConfigureAwait(false);
                var Convert = JsonConvert.DeserializeObject<EmailMessageSettingConfigs>(Single.Context);
                EmailMessageAPI = new EmailMessageAPI(Convert);

                var QueryAccount = await this.GlobalRunningSettingDomainService.Single(GlobalRunningSetting.EmailAccount).ConfigureAwait(false);
                this.SendMessageAccounts = QueryAccount.Context.Split(",").ToArray();
            }
            await CreateError(Ex).ConfigureAwait(false);
            await NotifiMe(Ex).ConfigureAwait(false);

            // 必须往上层抛出，方便上层进行处理
            //throw new Exception(JoreNoeRequestCommonTools.FormatError(Ex));
        }

        /// <summary>
        /// 存储数据
        /// </summary>
        /// <param name="Ex"></param>
        /// <returns></returns>
        public async Task CreateError(Exception Ex)
        {
            await this.GlobalRunningErrorHistoryRepository.AddAsync(new GlobalRunningErrorHistory
            {
                CreateTime = DateTime.Now,
                Id = Guid.NewGuid(),
                Message = JoreNoeRequestCommonTools.FormatError(Ex)
            }).ConfigureAwait(false);
        }

        /// <summary>
        /// 给我发送通知
        /// </summary>
        /// <param name="Ex"></param>
        public async Task NotifiMe(Exception Ex)
        {
            // 查询数据 
            if (this.SendMessageAccounts != null && this.SendMessageAccounts.Length != 0)
            {
                foreach (var SingleEmailAccount in this.SendMessageAccounts)
                {
                    try
                    {
                        await this.EmailMessageAPI.SendAsync(SingleEmailAccount,
                                                "项目：Dogegg出现了错误", "已记录数据，错误内容：" + JoreNoeRequestCommonTools.FormatError(Ex))
                                                .ConfigureAwait(false);
                    }
                    catch (Exception ex)
                    {

                        Console.WriteLine(ex.Message);
                    }
                }
            }
        }
    }
}

Program 文件

namespace Dogegg.API
{
    using Autofac;
    using Autofac.Extensions.DependencyInjection;
    using AutoMapper;
    using Dogegg.API.Extensions;
    using Dogegg.API.HostedServices;
    using Dogegg.API.Middlewares;
    using Dogegg.API.WeChatTemplateMessageService;
    using Dogegg.DomainService;
    using Exceptionless;
    using JoreNoe.Cache.Redis;
    using JoreNoe.DB.Dapper;
    using JoreNoe.Extend;
    using JoreNoe.JoreHttpClient;
    using JoreNoe.Middleware;
    using JoreNoe.Queue.RBMQ;
    using Microsoft.AspNetCore.Builder;
    using Microsoft.AspNetCore.HttpOverrides;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.DependencyInjection.Extensions;
    using Microsoft.OpenApi.Models;
    using Newtonsoft.Json.Converters;
    using System.Reflection;
    using Newtonsoft.Json;
    using Dogegg.API.Converts;

    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            // Add services to the container.

            // 设置 并发连接数，一般都是根据系统配置自定义的，可以不设置，设置为了测试使用
            builder.WebHost.ConfigureKestrel(options =>
            {
                options.Limits.MaxConcurrentConnections = int.MaxValue;
            });

            builder.Services.AddControllers()
                .AddJsonOptions(options =>
                {
                    // 默认配置  输出结构 讲不默认小写 将按照Model进行输出
                    options.JsonSerializerOptions.PropertyNamingPolicy = null;
                    options.JsonSerializerOptions.Converters.Add(new DateTimeToStringConvert());
                });
            // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
            builder.Services.AddEndpointsApiExplorer();
            builder.Services.AddSwaggerGen(d =>
            {
                // 启用注释
                d.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, string.Concat(Assembly.GetExecutingAssembly().GetName().Name, ".xml")));
                d.SwaggerDoc("v1",
                    new OpenApiInfo
                    {
                        Title = "Dogegg",
                        Version = "DogeggDevelopmentVersion",
                        Description = "DogeggAPIDocs",
                        Contact = new OpenApiContact
                        {
                            Email = "[e-mail]",
                            Name = "Jorenoe",
                            Url = new Uri("https://jorenoe.top")
                        },
                        TermsOfService = new Uri("https://jorenoe.top")
                    });
            });

            // 添加链路追踪
            //builder.Services.AddOpenTelemetry()
            //.WithTracing(tracerProviderBuilder =>
            //{
            //    var ProjectServiceName = Assembly.GetExecutingAssembly().GetName().Name;
            //    tracerProviderBuilder
            //        .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(ProjectServiceName ?? "default"))
            //        .AddAspNetCoreInstrumentation() // 为 ASP.NET Core 请求添加追踪
            //        .AddHttpClientInstrumentation() // 为 HttpClient 请求添加追踪
            //        .AddZipkinExporter(options =>
            //        {
            //            options.Endpoint = new Uri(builder.Configuration.GetSection("ZipKinUrl").Value ?? throw new ArgumentNullException("链路追踪地址为空")); // 设置 Zipkin 服务器的地址
            //        });
            //});

            // 开启缓存
            builder.Services.AddResponseCaching();


            builder.Services.AddHttpClientApi();

            // 加入JoreNoeDapper
            builder.Services.AddJoreNoeDapper(builder.Configuration.GetConnectionString("MysqlConnection"), IDBType.MySql, true,20000);

            // 加入JoreNoe-Redis数据库
            builder.Services.AddJoreNoeRedis(builder.Configuration.GetConnectionString("RedisConnection"), 0, true);

            // 加入JoreNoe全局运行中间件和全局错误中间件
            builder.Services.AddJoreNoeRequestLoggingMiddleware<GlobalSystemRunningMiddleware>();
            builder.Services.AddJoreNoeGlobalErrorHandlingMiddleware<GlobalSystemErrorMiddleware>(EnableReturnRecordErrorMessage: true);
            builder.Services.AddJoreNoeSystemIPBlackListMiddleware(300, TimeSpan.FromSeconds(60), TimeSpan.FromMinutes(6), true);
            builder.Services.AddJoreNoeJoreNoeIntefaceAccessMiddleware(LocalCacheDurationInMinutes: TimeSpan.FromMinutes(5));

            //rabbitmq
            builder.Services.AddJoreNoeRabbitMQ(builder.Configuration.GetConnectionString("RabbitMQConnection") ?? throw new ArgumentNullException("RabbitMQConnection IS NULL"));
            //加入Jorene 邮件短信 弃用注入方式，因为数据从数据库中读取，改为值引用
            //builder.Services.AddJoreNoeEmailMessage(,);

            // 替换容器为AutoFac并且注入DomainService
            var InstantAutoFacContiner = new AutofacServiceProviderFactory();
            builder.Host.UseServiceProviderFactory(InstantAutoFacContiner);
            builder.Host.ConfigureContainer<ContainerBuilder>(builder =>
            {
                builder.RegisterModule<DomainServiceModule>();
            });

            // 加入AutoMapper
            builder.Services.TryAddSingleton<MapperConfigurationExpression>();
            builder.Services.TryAddSingleton(serviceProvider =>
            {
                var mapperConfigurationExpression = serviceProvider.GetRequiredService<MapperConfigurationExpression>();
                var instance = new MapperConfiguration(mapperConfigurationExpression);
                instance.AssertConfigurationIsValid();
                return instance;
            });
            builder.Services.TryAddSingleton(serviceProvider =>
            {
                var mapperConfiguration = serviceProvider.GetRequiredService<MapperConfiguration>();
                return mapperConfiguration.CreateMapper();
            });

            // 加入跨域
            builder.Services.AddCors(options =>
            {
                options.AddPolicy("AllowAll",
                   builder =>
                   {
                       builder.AllowAnyOrigin()
                              .AllowAnyMethod()
                              .AllowAnyHeader();
                   });
            });

            // 加入Exceptionless
            builder.Services.AddExceptionless(builder.Configuration.GetSection("Exceptionless:APIKEY").Value ?? throw new ArgumentNullException("ExeptionLessConfiguration Is  NULL"));
            // 设置应用程序的启动地址和端口号
            builder.WebHost.UseUrls("http://*:6631");

            //增加定时 执行
            builder.Services.AddTransient<IndexWeChatServices>();
            builder.Services.AddHostedService<SendWeChatMessageServices>();
            builder.Services.AddHostedService<UserPointReloadSerivces>();
            builder.Services.AddHostedService<UserRankingServices>();
            var app = builder.Build();

            app.UsePathBase("/dogegg");

            // 加入JorenoeAutoFacResolve扩展
            AutofacResolverExtend.SetContainerFactory(() => app.Services.GetAutofacRoot());

            // 启用缓存
            app.UseResponseCaching();

            // 使用JoreNoe全局运行中间件和错误中间件
            app.UseJoreNoeRequestLoggingMiddleware();
            app.UseJoreNoeGlobalErrorHandlingMiddleware();
            app.UseJoreNoeSystemIPBlackListMiddleware();
            app.UseJoreNoeIntefaceAccessMiddleware();


            //IP服务
            app.UseForwardedHeaders(new ForwardedHeadersOptions
            {
                ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto,
                // 如果有已知的代理服务器，可以添加到 KnownProxies
                KnownNetworks = { }, // 可以为空
                KnownProxies = { } // 可以为空
            });

            // 使用AutoMapper配置
            app.UseAutoMapperConfigure();
            // 使用模型转换AutoMapper
            app.UseJoreNoeObjectToOBject();

            // 使用跨域
            app.UseCors("AllowAll");

            // 使用ExceptionLesson
            app.UseExceptionless();

            if (app.Environment.IsDevelopment() || app.Environment.IsProduction())
            {
                app.UseSwagger();
                // 如果指定位置就需要给前面加上前缀如果不需要 删除 拼接即可
                app.UseJoreNoeSwaggerThemeDark("/swagger");
                app.UseSwaggerUI(d =>
                {
                    d.InjectStylesheet(string.Concat("/dogegg", SwaggerThemsExtend.DarkTheme));
                    d.SwaggerEndpoint("v1/swagger.json", "Dogegg");
                    d.DefaultModelsExpandDepth(-1); // 禁用显示模型
                });
            }

            app.UseRouting();
            //app.UseRouting(); 配合全局 app.UserBasePath() 使用

            app.UseHttpsRedirection();

            app.UseAuthorization();

            app.MapControllers();

            app.Run();
        }
    }
}