Learn.Archives/Learn.Archives.Core/Common/AppCommon.cs

using FreeRedis;
using Learn.Archives.Core.Model;
using Learn.Archives.Core.Model.Interface;
using Microsoft.Extensions.DependencyModel;
using Microsoft.IdentityModel.Tokens;
using SqlSugar;
using SqlSugar.IOC;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.PortableExecutable;
using System.Runtime.Loader;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using UserCenter.Model.Interface;

namespace Learn.Archives.Core.Common
{

    /// <summary>
    /// 程序 公共变量
    /// </summary>
    public static class AppCommon
    {
        /// <summary>
        /// 应用有效程序集
        /// </summary>
        public static readonly IEnumerable<Assembly> Assemblies;
        /// <summary>
        /// 主库数据库表类型
        /// </summary>
        public static readonly IEnumerable<Type> DbMatserType;
        public static readonly IEnumerable<Type> UserCenterType;
        static AppCommon()
        {
            try
            {
                var projectName = Assembly.GetExecutingAssembly().GetName().Name;
                Assemblies = ExpandFunction.GetAssemblies();
                var assembliesType = Assemblies
                    //.Where(s => s.FullName.Contains(projectName))
                    .SelectMany(s => s.ExportedTypes.Where(u => !u.IsInterface && !u.IsAbstract && u.IsClass && u.IsDefined(typeof(SugarTable), false)));
                DbMatserType = assembliesType
                    .Where(u => u.GetInterfaces().Contains(typeof(IDB)));
                UserCenterType = assembliesType
                    .Where(u => u.FullName.Contains("UserCenter"));
            }
            catch
            {
                throw;
            }
        }
        /// <summary>
        /// 程序配置
        /// </summary>
        public static AppConfig Config = new AppConfig();
        /// <summary>
        /// ServiceProvider
        /// </summary>
        public static IServiceProvider? Services;

    }

    /// <summary>
    /// 拓展函数
    /// </summary>
    public static class ExpandFunction
    {

        static Dictionary<string, string> FormulaData;
        static string FormulaDataKey;
        /// <summary>
        /// 帧文件名称
        /// </summary>
        public static string FrameName = "frame_";

        /// <summary>
        /// 对象转化为JSON字符串
        /// </summary>
        /// <param name="o">拓展对象</param>
        /// <param name="WriteIndented">美化输出?</param>
        /// <returns></returns>
        public static string ToJson(this object o, bool WriteIndented = false)
        {
            var jsonOptions = new JsonSerializerOptions
            {
                Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
                WriteIndented = WriteIndented // 如果需要美化输出
            };
            return JsonSerializer.Serialize(o, jsonOptions);
        }


        /// <summary>
        /// 获取应用有效程序集
        /// </summary>
        /// <returns>IEnumerable</returns>
        public static List<Assembly> GetAssemblies()
        {
            // 获取当前解决方案的所有程序集 
            var assembliesStr = DependencyContext.Default.RuntimeLibraries
            .Where(u => !u.Name.StartsWith(nameof(Microsoft))
                && !u.Name.StartsWith(nameof(System))
                 && !u.Name.StartsWith("netstandard")
                 && u.Type == "project");

            var assemblies = assembliesStr.Select(a => AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(a.Name))).ToList();
            var assemblies1 = Assembly.GetEntryAssembly().GetReferencedAssemblies().Where(x => x.Name.StartsWith("App.") || x.Name.StartsWith("UserCenter."))
                .Select(a => AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(a.Name))).ToList();
            foreach (var item in assemblies1)
            {
                if (!assemblies.Contains(item))
                    assemblies.Add(item);
            }
            return assemblies;
        }

        /// <summary>
        /// 获取下一个枚举值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="current"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        public static T? NextEnum<T>(this T current) where T : struct, Enum
        {
            if (!typeof(T).IsEnum)
                throw new ArgumentException("传入类型不是枚举");
            T[] values = (T[])Enum.GetValues(typeof(T));
            int currentIndex = Array.IndexOf(values, current);
            if (currentIndex == values.Length - 1)
                return null;
            int nextIndex = (currentIndex + 1) % values.Length;
            return values[nextIndex];
        }
        /// <summary>
        /// 转化枚举
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static T? ToEnum<T>(this object value) where T : struct, Enum
        {
            try
            {
                if (value is null || string.IsNullOrEmpty(value.ToString()))
                    return null;
                if (Enum.TryParse<T>(value.ToString(), true, out var result) && Enum.IsDefined(typeof(T), result))
                    return result;
                return null;
            }
            catch (Exception)
            {
                return null;
            }
        }

    }

}