first commit

2026-09-02 16:31:50 +08:00
commit a461727193
911 changed files with 692450 additions and 0 deletions
@@ -0,0 +1,123 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text.RegularExpressions;
+
+namespace JSMachine.WMS.Infrastructure
+{
+    public interface IGenericInterface
+    {
+        Type Type { get; }
+
+        Type[] GenericArguments { get; }
+
+        TDelegate GetMethod<TDelegate>(string methodName, params Type[] argTypes);
+    }
+
+    public static class GenericInterfaceExtensions
+    {
+        public static IGenericInterface AsGenericInterface(this object @this, Type type)
+        {
+            var interfaceType = (
+                    from @interface in @this.GetType().GetInterfaces()
+                    where @interface.IsGenericType
+                    let definition = @interface.GetGenericTypeDefinition()
+                    where definition == type
+                    select @interface
+                )
+                .SingleOrDefault();
+
+            return interfaceType != null
+                ? new GenericInterfaceImpl(@this, interfaceType)
+                : null;
+        }
+
+        private class GenericInterfaceImpl : IGenericInterface
+        {
+            private static readonly Regex ActionDelegateRegex = new Regex(@"^System\.Action(`\d{1,2})?", RegexOptions.Compiled);
+            private static readonly Regex FuncDelegateRegex = new Regex(@"^System\.Func`(\d{1,2})", RegexOptions.Compiled);
+
+            private readonly object _instance;
+
+            public Type Type { get; }
+
+            public Type[] GenericArguments => Type.GetGenericArguments();
+
+            public GenericInterfaceImpl(object instance, Type interfaceType)
+            {
+                _instance = instance;
+                Type = interfaceType;
+            }
+
+            public TDelegate GetMethod<TDelegate>(string methodName, params Type[] argTypes)
+            {
+                switch (GetDelegateType<TDelegate>())
+                {
+                    case DelegateType.Action:
+                        return GetAction<TDelegate>(methodName);
+                    case DelegateType.ActionWithParams:
+                        return GetActionWithParams<TDelegate>(methodName, argTypes);
+                    default:
+                        throw new NotSupportedException();
+                }
+            }
+
+            private TDelegate GetActionWithParams<TDelegate>(string methodName, params Type[] argTypes)
+            {
+                var methodInfo = Type.GetMethod(methodName) ?? throw new ArgumentException(nameof(methodName));
+                var argTypeList = argTypes.Any() ? argTypes : typeof(TDelegate).GetGenericArguments();
+                (ParameterExpression expression, Type type)[] argObjectParameters = argTypeList
+                    .Select(item => (Expression.Parameter(typeof(object)), item))
+                    .ToArray();
+
+                var method = Expression.Lambda<TDelegate>(
+                        Expression.Call(
+                            Expression.Constant(_instance),
+                            methodInfo,
+                            argObjectParameters.Select(item => Expression.Convert(item.expression, item.type))),
+                        argObjectParameters.Select(item => item.expression))
+                    .Compile();
+
+                return method;
+            }
+
+            private TDelegate GetAction<TDelegate>(string methodName)
+            {
+                var methodInfo = Type.GetMethod(methodName) ?? throw new ArgumentException(nameof(methodName));
+                var method = Expression.Lambda<TDelegate>(
+                        Expression.Call(
+                            Expression.Constant(_instance),
+                            methodInfo))
+                    .Compile();
+
+                return method;
+            }
+
+            private static DelegateType GetDelegateType<TDelegate>()
+            {
+                var actionMatch = ActionDelegateRegex.Match(typeof(TDelegate).FullName ?? throw new InvalidOperationException());
+                if (actionMatch.Success)
+                {
+                    return actionMatch.Groups.Count > 1 ? DelegateType.ActionWithParams : DelegateType.Action;
+                }
+
+                var funcMatch = FuncDelegateRegex.Match(typeof(TDelegate).FullName ?? throw new InvalidOperationException());
+                if (funcMatch.Success)
+                {
+                    return int.Parse(actionMatch.Groups[1].Value) > 1 ? DelegateType.FuncWithParams : DelegateType.Func;
+                }
+
+                return DelegateType.NotSupported;
+            }
+
+            private enum DelegateType
+            {
+                NotSupported,
+                Action,
+                Func,
+                ActionWithParams,
+                FuncWithParams
+            }
+        }
+    }
+}