登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›GlobalService类

GlobalService类

袁勤 2025-6-28 23:59:57
  1. public class GlobalService
  2. {
  3.     private static IServiceScope? _currentScope;
  4.     private static readonly Lazy<string> _serverAddress = new Lazy<string>(GetServerAddress, true);
  5.     private static readonly Lazy<string> _serverPort = new Lazy<string>(GetServerPort, true);
  6.     private static DateTime? _serviceStartTime;
  8.     // 核心服务
  9.     public static ILogger? Logger { get; private set; }
  10.     public static IWebHostEnvironment? WebHostEnvironment { get; private set; }
  11.     public static IServiceProvider? ServiceProvider { get; private set; }
  12.     public static IConfiguration? Configuration { get; private set; }
  13.     public static IHttpContextAccessor? HttpContextAccessor { get; private set; }
  14.     public static IHostApplicationLifetime? ApplicationLifetime { get; private set; }
  16.     // 使用Lazy<T>实现线程安全的延迟初始化
  17.     private static readonly Lazy<IServiceScope> _lazyScope = new Lazy<IServiceScope>(
  18.         () => ServiceProvider!.CreateScope(),
  19.         LazyThreadSafetyMode.ExecutionAndPublication
  20.     );
  22.     #region 便捷访问属性 - 环境与应用信息
  23.     /// <summary>当前应用程序名称</summary>
  24.     public static string ApplicationName => WebHostEnvironment?.ApplicationName ?? "UnknownApp";
  26.     /// <summary>当前环境名称（Development/Production等）</summary>
  27.     public static string EnvironmentName => WebHostEnvironment?.EnvironmentName ?? "Unknown";
  29.     /// <summary>应用程序根路径</summary>
  30.     public static string ContentRootPath => WebHostEnvironment?.ContentRootPath ?? "";
  32.     /// <summary>Web静态文件根路径</summary>
  33.     public static string WebRootPath => WebHostEnvironment?.WebRootPath ?? "";
  35.     /// <summary>服务启动时间</summary>
  36.     public static DateTime ServiceStartTime => _serviceStartTime ??= DateTime.Now;
  38.     /// <summary>服务已运行时间</summary>
  39.     public static TimeSpan ServiceUptime => DateTime.Now - ServiceStartTime;
  41.     /// <summary>检查应用是否处于开发环境</summary>
  42.     public static bool IsDevelopment => WebHostEnvironment?.IsDevelopment() ?? false;
  44.     /// <summary>检查应用是否处于生产环境</summary>
  45.     public static bool IsProduction => WebHostEnvironment?.IsProduction() ?? false;
  46.     #endregion
  47.     #region 便捷访问属性 - 系统信息
  48.     /// <summary>获取操作系统信息</summary>
  49.     public static string OSInformation => Environment.OSVersion.ToString();
  51.     /// <summary>获取.NET运行时版本</summary>
  52.     public static string RuntimeVersion => Environment.Version.ToString();
  54.     /// <summary>获取应用进程ID</summary>
  55.     public static int ProcessId => Process.GetCurrentProcess().Id;
  56.     #endregion
  58.     #region 便捷访问属性 - 客户端信息
  59.     /// <summary>获取当前请求的客户端IPv4地址（支持代理服务器场景）</summary>
  60.     public static string ClientIPv4Address
  61.     {
  62.         get
  63.         {
  64.             try
  65.             {
  66.                 var context = HttpContextAccessor?.HttpContext;
  67.                 if (context == null) return "Unknown";
  69.                 // 优先从请求头获取代理IP（如Nginx/X-Forwarded-For）
  70.                 var ip = context.Request.Headers["X-Forwarded-For"].FirstOrDefault();
  71.                 if (string.IsNullOrEmpty(ip))
  72.                 {
  73.                     ip = context.Connection.RemoteIpAddress?.ToString();
  74.                 }
  76.                 // 提取IPv4地址（处理可能的端口或IPv6格式）
  77.                 if (ip != null)
  78.                 {
  79.                     var parts = ip.Split(',', ':', ']').FirstOrDefault(p => !string.IsNullOrEmpty(p.Trim()));
  80.                     if (IPAddress.TryParse(parts, out var address) && address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
  81.                     {
  82.                         return address.ToString();
  83.                     }
  84.                 }
  85.                 return "Unknown";
  86.             }
  87.             catch
  88.             {
  89.                 return "Unknown";
  90.             }
  91.         }
  92.     }
  94.     /// <summary>获取当前请求的客户端端口号</summary>
  95.     public static int? ClientPort
  96.     {
  97.         get
  98.         {
  99.             try
  100.             {
  101.                 return HttpContextAccessor?.HttpContext?.Connection?.RemotePort;
  102.             }
  103.             catch
  104.             {
  105.                 return null;
  106.             }
  107.         }
  108.     }
  110.     /// <summary>获取当前请求的完整URL</summary>
  111.     public static string? CurrentRequestUrl
  112.     {
  113.         get
  114.         {
  115.             try
  116.             {
  117.                 var context = HttpContextAccessor?.HttpContext;
  118.                 if (context == null) return null;
  120.                 return $"{context.Request.Scheme}://{context.Request.Host}{context.Request.Path}{context.Request.QueryString}";
  121.             }
  122.             catch
  123.             {
  124.                 return null;
  125.             }
  126.         }
  127.     }
  129.     /// <summary>获取当前认证用户的ID（如果有）</summary>
  130.     public static string? CurrentUserId
  131.     {
  132.         get
  133.         {
  134.             try
  135.             {
  136.                 var context = HttpContextAccessor?.HttpContext;
  137.                 return context?.User?.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier")?.Value;
  138.             }
  139.             catch
  140.             {
  141.                 return null;
  142.             }
  143.         }
  144.     }
  146.     /// <summary>获取当前认证用户的名称（如果有）</summary>
  147.     public static string? CurrentUserName
  148.     {
  149.         get
  150.         {
  151.             try
  152.             {
  153.                 var context = HttpContextAccessor?.HttpContext;
  154.                 return context?.User?.Identity?.Name;
  155.             }
  156.             catch
  157.             {
  158.                 return null;
  159.             }
  160.         }
  161.     }
  162.     #endregion
  164.     #region 便捷访问属性 - 服务地址信息
  165.     /// <summary>获取当前服务侦听的IPv4地址</summary>
  166.     public static string ServerAddress => _serverAddress.Value;
  168.     /// <summary>获取当前服务侦听的端口号</summary>
  169.     public static string ServerPort => _serverPort.Value;
  171.     /// <summary>获取服务正在监听的完整地址（包含协议和端口）</summary>
  172.     public static string ServiceListeningAddress
  173.     {
  174.         get
  175.         {
  176.             try
  177.             {
  178.                 if (ServiceProvider == null) return "Unknown";
  179.                 var server = ServiceProvider.GetRequiredService<IServer>();
  180.                 var addressesFeature = server.Features.Get<IServerAddressesFeature>();
  181.                 if (addressesFeature?.Addresses == null || !addressesFeature.Addresses.Any())
  182.                 {
  183.                     return "Unknown";
  184.                 }
  186.                 return addressesFeature.Addresses.First();
  187.             }
  188.             catch
  189.             {
  190.                 return "Unknown";
  191.             }
  192.         }
  193.     }
  195.     /// <summary>获取当前服务实例的IPv4地址（不包含端口）</summary>
  196.     public static string ServiceIPv4Address
  197.     {
  198.         get
  199.         {
  200.             try
  201.             {
  202.                 var host = Dns.GetHostEntry(Dns.GetHostName());
  203.                 foreach (var ip in host.AddressList)
  204.                 {
  205.                     if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
  206.                     {
  207.                         return ip.ToString();
  208.                     }
  209.                 }
  210.                 return "127.0.0.1";
  211.             }
  212.             catch
  213.             {
  214.                 return "127.0.0.1";
  215.             }
  216.         }
  217.     }
  219.     /// <summary>获取当前服务实例的端口号</summary>
  220.     public static int ServicePort
  221.     {
  222.         get
  223.         {
  224.             try
  225.             {
  226.                 var address = ServiceListeningAddress;
  227.                 if (string.IsNullOrEmpty(address)) return 0;
  229.                 if (Uri.TryCreate(address, UriKind.Absolute, out var uri))
  230.                 {
  231.                     return uri.Port;
  232.                 }
  233.                 else if (address.Contains(":"))
  234.                 {
  235.                     var parts = address.Split(':').LastOrDefault();
  236.                     if (int.TryParse(parts, out var port))
  237.                     {
  238.                         return port;
  239.                     }
  240.                 }
  241.                 return 0;
  242.             }
  243.             catch
  244.             {
  245.                 return 0;
  246.             }
  247.         }
  248.     }
  249.     #endregion
  251.     #region 便捷访问属性 - 请求信息
  252.     /// <summary>获取当前请求路径</summary>
  253.     public static string? RequestPath => HttpContextAccessor?.HttpContext?.Request?.Path;
  255.     /// <summary>获取当前请求方法（GET/POST等）</summary>
  256.     public static string? RequestMethod => HttpContextAccessor?.HttpContext?.Request?.Method;
  257.     #endregion
  259.     /// <summary>创建临时服务作用域（使用后需手动释放）</summary>
  260.     public static IServiceScope CreateScope() => ServiceProvider!.CreateScope();
  262.     /// <summary>获取当前活动的作用域（单例模式）</summary>
  263.     public static IServiceScope CurrentScope => _lazyScope.Value;
  265.     /// <summary>初始化全局服务（在应用启动时调用）</summary>
  266.     public static void Initialize(IServiceProvider serviceProvider)
  267.     {
  268.         ServiceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
  270.         // 从服务容器中获取核心服务
  271.         WebHostEnvironment = serviceProvider.GetRequiredService<IWebHostEnvironment>();
  272.         Configuration = serviceProvider.GetRequiredService<IConfiguration>();
  273.         HttpContextAccessor = serviceProvider.GetRequiredService<IHttpContextAccessor>();
  274.         ApplicationLifetime = serviceProvider.GetRequiredService<IHostApplicationLifetime>();
  276.         // 创建全局日志记录器
  277.         Logger = serviceProvider.GetRequiredService<ILoggerFactory>()
  278.                                .CreateLogger("GlobalService");
  279.     }
  281.     /// <summary>释放全局资源</summary>
  282.     public static void Dispose()
  283.     {
  284.         if (_lazyScope.IsValueCreated)
  285.         {
  286.             _lazyScope.Value.Dispose();
  287.         }
  288.         _currentScope = null;
  289.     }
  291.     /// <summary>从当前作用域获取服务</summary>
  292.     public static T GetService<T>() where T : notnull
  293.         => CurrentScope.ServiceProvider.GetRequiredService<T>();
  295.     /// <summary>从临时作用域获取服务（使用后需释放作用域）</summary>
  296.     public static T GetScopedService<T>() where T : notnull
  297.         => CreateScope().ServiceProvider.GetRequiredService<T>();
  299.     /// <summary>从配置中获取强类型配置对象</summary>
  300.     public static T GetConfig<T>(string sectionName) where T : new()
  301.     {
  302.         var config = new T();
  303.         Configuration?.GetSection(sectionName).Bind(config);
  304.         return config;
  305.     }
  307.     /// <summary>从配置中获取值</summary>
  308.     public static string? GetConfigValue(string key) => Configuration?[key];
  310.     /// <summary>优雅地停止应用程序</summary>
  311.     public static void StopApplication() => ApplicationLifetime?.StopApplication();
  313.     // Fix for CS1061: Replace the incorrect usage of `ServerFeatures` with the correct way to access `IServerAddressesFeature` from the service provider.
  315.     private static string GetServerAddress()
  316.     {
  317.         try
  318.         {
  319.             if (ServiceProvider == null) return "Unknown";
  320.             var server = ServiceProvider.GetRequiredService<IServer>();
  321.             var addresses = server.Features.Get<IServerAddressesFeature>()?.Addresses;
  323.             return addresses?
  324.                 .Select(a => new Uri(a))
  325.                 .FirstOrDefault(uri =>
  326.                     uri.Host == "localhost" ||
  327.                     uri.Host == "127.0.0.1" ||
  328.                     uri.Host.Contains('.')
  329.                 )?.Host ?? "Unknown";
  330.         }
  331.         catch
  332.         {
  333.             return "Unknown";
  334.         }
  335.     }
  337.     private static string GetServerPort()
  338.     {
  339.         try
  340.         {
  341.             if (ServiceProvider == null) return "Unknown";
  342.             var server = ServiceProvider.GetRequiredService<IServer>();
  343.             var addresses = server.Features.Get<IServerAddressesFeature>()?.Addresses;
  345.             return addresses?
  346.                 .Select(a => new Uri(a))
  347.                 .FirstOrDefault()?
  348.                 .Port.ToString() ?? "Unknown";
  349.         }
  350.         catch
  351.         {
  352.             return "Unknown";
  353.         }
  354.     }
  357.     #region 便捷访问属性 - 内存使用
  358.     /// <summary>获取当前应用的内存使用情况</summary>
  359.     public static MemoryInfo GetMemoryInfo()
  360.     {
  361.         try
  362.         {
  363.             var process = Process.GetCurrentProcess();
  364.             return new MemoryInfo
  365.             {
  366.                 WorkingSet = process.WorkingSet64 / (1024 * 1024), // MB
  367.                 PrivateMemorySize = process.PrivateMemorySize64 / (1024 * 1024), // MB
  368.                 VirtualMemorySize = process.VirtualMemorySize64 / (1024 * 1024), // MB
  369.                 PeakWorkingSet = process.PeakWorkingSet64 / (1024 * 1024), // MB
  370.                 PeakPrivateMemorySize = process.PrivateMemorySize64 / (1024 * 1024),
  371.                 PeakVirtualMemorySize = process.PeakVirtualMemorySize64 / (1024 * 1024) // MB
  372.             };
  373.         }
  374.         catch (Exception ex)
  375.         {
  376.             LogException(ex, nameof(GetMemoryInfo));
  377.             return new MemoryInfo();
  378.         }
  379.     }
  381.     // 在GlobalService类中添加以下方法
  382.     private static void LogException(Exception ex, string methodName)
  383.     {
  384.         Logger?.LogError(ex, $"GlobalService方法[{methodName}]发生异常: {ex.Message}");
  385.     }
  387.     /// <summary>内存使用信息类</summary>
  388.     public class MemoryInfo
  389.     {
  390.         public long WorkingSet { get; set; }       // 工作集(MB)
  391.         public long PrivateMemorySize { get; set; } // 私有内存(MB)
  392.         public long VirtualMemorySize { get; set; } // 虚拟内存(MB)
  393.         public long PeakWorkingSet { get; set; }    // 峰值工作集(MB)
  394.         public long PeakPrivateMemorySize { get; set; } // 峰值私有内存(MB)
  395.         public long PeakVirtualMemorySize { get; set; } // 峰值虚拟内存(MB)
  396.     }
  397.     #endregion
  399.     /// <summary>
  400.     /// 获取GlobalService中所有可展示的信息
  401.     /// </summary>
  402.     /// <param name="useChinese">是否使用中文显示，默认使用英文</param>
  403.     /// <returns>包含所有信息的字典，键为显示名称，值为对应值</returns>
  404.     public static Dictionary<string, object> GetAllDisplayInfo(bool useChinese = false)
  405.     {
  406.         // 中英文显示名称映射
  407.         var displayNames = new Dictionary<string, string>
  408.     {
  409.         // 环境与应用信息
  410.         { "ApplicationName", useChinese ? "应用程序名称" : "Application Name" },
  411.         { "EnvironmentName", useChinese ? "环境名称" : "Environment Name" },
  412.         { "ContentRootPath", useChinese ? "应用程序根路径" : "Content Root Path" },
  413.         { "WebRootPath", useChinese ? "Web静态文件根路径" : "Web Root Path" },
  414.         { "ServiceStartTime", useChinese ? "服务启动时间" : "Service Start Time" },
  415.         { "ServiceUptime", useChinese ? "服务已运行时间" : "Service Uptime" },
  416.         { "IsDevelopment", useChinese ? "是否开发环境" : "Is Development" },
  417.         { "IsProduction", useChinese ? "是否生产环境" : "Is Production" },
  418.         
  419.         // 客户端信息
  420.         { "ClientIPv4Address", useChinese ? "客户端IPv4地址" : "Client IPv4 Address" },
  421.         { "ClientPort", useChinese ? "客户端端口号" : "Client Port" },
  422.         { "CurrentRequestUrl", useChinese ? "当前请求URL" : "Current Request URL" },
  423.         { "CurrentUserId", useChinese ? "当前用户ID" : "Current User ID" },
  424.         { "CurrentUserName", useChinese ? "当前用户名称" : "Current User Name" },
  425.         
  426.         // 服务地址信息
  427.         { "ServerAddress", useChinese ? "服务侦听地址" : "Server Address" },
  428.         { "ServerPort", useChinese ? "服务侦听端口" : "Server Port" },
  429.         { "ServiceListeningAddress", useChinese ? "服务监听地址" : "Service Listening Address" },
  430.         { "ServiceIPv4Address", useChinese ? "服务实例IP地址" : "Service IPv4 Address" },
  431.         { "ServicePort", useChinese ? "服务实例端口" : "Service Port" },
  432.         
  433.         // 请求信息
  434.         { "RequestPath", useChinese ? "当前请求路径" : "Request Path" },
  435.         { "RequestMethod", useChinese ? "当前请求方法" : "Request Method" },
  437.             { "OSInformation", useChinese ? "操作系统信息" : "OS Information" },
  438. { "RuntimeVersion", useChinese ? ".NET运行时版本" : "Runtime Version" },
  439. { "ProcessId", useChinese ? "进程ID" : "Process ID" },
  441.     { "MemoryInfo.WorkingSet", useChinese ? "工作集(MB)" : "Working Set (MB)" },
  442.         { "MemoryInfo.PrivateMemorySize", useChinese ? "私有内存(MB)" : "Private Memory Size (MB)" },
  443.         { "MemoryInfo.VirtualMemorySize", useChinese ? "虚拟内存(MB)" : "Virtual Memory Size (MB)" },
  444.         { "MemoryInfo.PeakWorkingSet", useChinese ? "峰值工作集(MB)" : "Peak Working Set (MB)" },
  445.         { "MemoryInfo.PeakPrivateMemorySize", useChinese ? "峰值私有内存(MB)" : "Peak Private Memory Size (MB)" },
  446.         { "MemoryInfo.PeakVirtualMemorySize", useChinese ? "峰值虚拟内存(MB)" : "Peak Virtual Memory Size (MB)" },
  447.     };
  449.         // 初始化结果字典
  450.         var result = new Dictionary<string, object>();
  452.         // 添加环境与应用信息
  453.         result.Add("ApplicationName", ApplicationName);
  454.         result.Add("EnvironmentName", EnvironmentName);
  455.         result.Add("ContentRootPath", ContentRootPath);
  456.         result.Add("WebRootPath", WebRootPath);
  457.         result.Add("ServiceStartTime", ServiceStartTime);
  458.         result.Add("ServiceUptime", ServiceUptime);
  459.         result.Add("IsDevelopment", IsDevelopment);
  460.         result.Add("IsProduction", IsProduction);
  462.         // 添加客户端信息
  463.         result.Add("ClientIPv4Address", ClientIPv4Address);
  464.         result.Add("ClientPort", ClientPort);
  465.         result.Add("CurrentRequestUrl", CurrentRequestUrl);
  466.         result.Add("CurrentUserId", CurrentUserId);
  467.         result.Add("CurrentUserName", CurrentUserName);
  469.         // 添加服务地址信息
  470.         result.Add("ServerAddress", ServerAddress);
  471.         result.Add("ServerPort", ServerPort);
  472.         result.Add("ServiceListeningAddress", ServiceListeningAddress);
  473.         result.Add("ServiceIPv4Address", ServiceIPv4Address);
  474.         result.Add("ServicePort", ServicePort);
  476.         // 添加请求信息
  477.         result.Add("RequestPath", RequestPath);
  478.         result.Add("RequestMethod", RequestMethod);
  481.         result.Add("OSInformation", OSInformation);
  482.         result.Add("RuntimeVersion", RuntimeVersion);
  483.         result.Add("ProcessId", ProcessId);
  485.         // 内存信息添加逻辑
  486.         var memoryInfo = GetMemoryInfo();
  487.         result.Add("MemoryInfo.WorkingSet", memoryInfo.WorkingSet);
  488.         result.Add("MemoryInfo.PrivateMemorySize", memoryInfo.PrivateMemorySize);
  489.         result.Add("MemoryInfo.VirtualMemorySize", memoryInfo.VirtualMemorySize);
  490.         result.Add("MemoryInfo.PeakWorkingSet", memoryInfo.PeakWorkingSet);
  491.         result.Add("MemoryInfo.PeakPrivateMemorySize", memoryInfo.PeakPrivateMemorySize);
  492.         result.Add("MemoryInfo.PeakVirtualMemorySize", memoryInfo.PeakVirtualMemorySize);
  494.         // 转换为显示名称并返回
  495.         return result.ToDictionary(
  496.             kvp => displayNames[kvp.Key],
  497.             kvp => kvp.Value
  498.         );
  499.     }
  500. }
复制代码
  1. var builder = WebApplication.CreateBuilder(args);
  3. // Add services to the container.
  5. builder.Services.AddControllers();
  6. // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
  7. builder.Services.AddEndpointsApiExplorer();
  8. builder.Services.AddSwaggerGen();
  10. builder.Services.AddHttpContextAccessor();
  12. var app = builder.Build();
  14. // Configure the HTTP request pipeline.
  15. if (app.Environment.IsDevelopment())
  16. {
  17.     app.UseSwagger();
  18.     app.UseSwaggerUI();
  19. }
  20. //初始化服务
  21. GlobalService.Initialize(app.Services);
  22. app.UseHttpsRedirection();
  24. app.UseAuthorization();
  26. app.MapControllers();
  28. app.Run();
复制代码
  1. [HttpGet]
  2. public IActionResult GetAllDisplayInfoApi()
  3. {
  4.         var serverAddress = GlobalService.GetAllDisplayInfo(true);
  5.         return Ok(serverAddress);
  6. }
复制代码
1.png


来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
袁勤
2025-6-28 23:59:57

0

粉丝关注

17

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫