泛型、Lambda 和反射问题 [复杂]

Question

在开始解释代码之前，我将首先给出我的用例，以便您可以了解发生了什么以及为什么发生。

先决条件：

• 要有一台服务器（客户端服务器术语中的队列调度程序/缓冲区）
• 要有一个或多个管理客户端（客户端服务器术语中的生产者）
• 要有客户端（客户端服务器术语中的消费者）

工作流程：

• 管理客户端编写一个 C#脚本，发送到服务器
• 脚本由 C# CodeDomProvider 编译，
• 脚本可以返回 CallQueue 结果，或者
• 如果发生服务器缓存 CallQueue，则
• 在服务器上执行某些操作，同时其他管理客户端可以发送新的脚本，这些脚本是已处理
• 一些客户端连接到服务器并请求 CallQueue
• 客户端获取 CallQueue 并在其中指定的时间执行它

到目前为止一切正常，并且工作完美。

现在是技术部分：

CallQueue 是一个类，它使用 lambda 表达式作为通用方法的输入，并存储在客户端队列中执行调用所需的反射数据。

为什么所有这些复杂性.. lambda 泛型等？类型安全。 管理客户端是愚蠢的，只需要知道一些脚本方法就可以编写，而不是真正的程序员。因此，发送整数而不是字符串或用拼写错误命名属性可能很常见。这就是脚本使用 lambda 和泛型来限制某人可以输入的内容的原因。

这将在服务器上进行编译，如果错误则被拒绝。

这是一个管理客户端将编写的符号脚本：

    CallQueue cc = new CallQueue(new DateTime(2012,12,21,10,0,0));

    // set property Firstname to "test person"
    cc.AddPropertySet<Person, string>(x => x.FirstName, "test person");

    // call method ChangeDescription with parameter "test order"
    cc.AddVoidMethodCall<Order, string>(x => x.ChangeDescription, "test order");

    // call method Utility.CreateGuid and send result to Person.PersonId
    cc.AddFunctionCallWithDestinationPropertySet<Utility, Guid, Person>(src => src.CreateGuid, dst => dst.PersonId);

客户端将获得一个 CallQueue 实例并像这样执行它：

    Order order = new Order();
    Person person = new Person();
    Utility util = new Utility();

    CallQueue cc = /* already got from server */;

    // when you call this execute the call queue will do the work
    // on object instances sent inside the execute method
    cc.Execute(new List<object> { order, person, util });

到目前为止，一切都很好且类型安全，但有一些含义：

• 客户端确切地知道必须将哪些对象发送到执行方法，由设计硬编码
• 管理客户端可以编写脚本，该脚本对不会发送到但仍然在服务器上编译的对象进行操作，因为类型存在

举个例子：

 cc.AddFunctionCall<Int32, string>(x => x.ToString);

这将编译，但当客户端执行它时会失败，因为它不存在将 Int32 发送到执行方法中。

好吧，巴拉巴拉…… 所以问题是：

如何用一组允许的类型来限制这些泛型方法 - 不是通过定义继承：

 where T : something

而是更像

 where listOftypes.Contains(T)

或任何限制可以进入其中的内容的等效解决方案...... 我没有找到对此的通用约束...

这是 CallQueue 类：

   [Serializable]
   public class CallQueue : List<CallQueue.Call>
    {
        [Serializable]
        public struct Call {
            public MethodInfo Method;
            public MethodInfo DestinationProperty;
            public object[] Parameters;
            public Call(MethodInfo m, MethodInfo d, object[] p) {
                Method = m;
                Parameters = p;
                DestinationProperty = d;
            }
        }

        public CallQueue(DateTime when) {
            ScheduledTime = when;
        }

        public DateTime ScheduledTime
        {
            get;
            set;
        }

        public void AddFunctionCall<TSrcClass, TResult>(Expression<Func<TSrcClass, Func<TResult>>> expr)
        {
            MethodResolver((LambdaExpression)expr, null, new object[] {});
        }

        public void AddFunctionCallWithDestinationPropertySet<TSrcClass, TResult, TDest>(Expression<Func<TSrcClass, Func<TResult>>> expr, Expression<Func<TDest, TResult>> dest)
        {
            MethodResolver((LambdaExpression)expr, dest,  new object[] { });
        }

        public void AddFunctionCallWithDestinationPropertySet<TSrcClass, TParam1, TResult, TDest>(Expression<Func<TSrcClass, Func<TParam1, TResult>>> expr, TParam1 param, Expression<Func<TDest, TResult>> dest)
        {
            MethodResolver((LambdaExpression)expr, dest, new object[] { param });
        }

        public void AddFunctionCall<TSrcClass, TParam1, TResult>(Expression<Func<TSrcClass, Func<TParam1, TResult>>> expr, TParam1 param)
        {
            MethodResolver((LambdaExpression)expr, null, new object[] {param});
        }

        public void AddFunctionCallWithDestinationPropertySet<TSrcClass, TParam1, TParam2, TResult, TDest>(Expression<Func<TSrcClass, Func<TParam1, TParam2, TResult>>> expr, TParam1 param, TParam2 param2, Expression<Func<TDest, TResult>> dest)
        {
            MethodResolver((LambdaExpression)expr, dest, new object[] { param, param2 });
        }

        public void AddFunctionCall<TSrcClass, TParam1, TParam2, TResult>(Expression<Func<TSrcClass, Func<TParam1, TParam2, TResult>>> expr, TParam1 param, TParam2 param2)
        {
            MethodResolver((LambdaExpression)expr, null, new object[] { param, param2 });
        }

        public void AddVoidMethodCall<TSrcClass, TParam>(Expression<Func<TSrcClass, Action<TParam>>> expr, TParam param)
        {
            MethodResolver((LambdaExpression)expr, null, new object[] { param });
        }

        public void AddVoidMethodCall<TSrcClass, TParam1, TParam2>(Expression<Func<TSrcClass, Action<TParam1, TParam2>>> expr, TParam1 param, TParam2 param2)
        {
            MethodResolver((LambdaExpression)expr, null, new object[] { param, param2 });
        }

        public void AddVoidMethodCall<TSrcClass, TParam1, TParam2, TParam3>(Expression<Func<TSrcClass, Action<TParam1, TParam2, TParam3>>> expr, TParam1 param, TParam2 param2, TParam3 param3)
        {
            MethodResolver((LambdaExpression)expr, null, new object[] { param, param2, param3 });
        }

        public void AddPropertySet<TSrcClass, TParam1>(Expression<Func<TSrcClass, TParam1>> expr, TParam1 param)
        {
            PropertyResolver((LambdaExpression)expr, new object[] {param});
        }

        public void Execute(List<object> instances) {
            foreach (var call in this) {
                var owner = instances.Find(o => o.GetType() == call.Method.DeclaringType);
                if (call.DestinationProperty != null)
                {
                    // execute method get result and set to destination property
                    object res = call.Method.Invoke(owner, call.Parameters);
                    var destOwner = instances.Find(o => o.GetType() == call.DestinationProperty.DeclaringType);
                    call.DestinationProperty.Invoke(destOwner, new object[] {res});
                }
                else 
                {
                    // just execute method
                    call.Method.Invoke(owner, call.Parameters);
                }
            }
        }

        private void MethodResolver(LambdaExpression expr, LambdaExpression dest, object[] param)
        {
            var body = (UnaryExpression)expr.Body;
            var methodCall = (MethodCallExpression)body.Operand;
            var constant = (ConstantExpression)methodCall.Arguments[2];
            var method = (MethodInfo)constant.Value;

            MethodInfo dmethod = null;

            if (dest != null)
            {
                var prop = (MemberExpression)dest.Body;
                var propMember = (PropertyInfo)prop.Member;
                dmethod = propMember.GetSetMethod();
            }

            this.Add(new Call(method, dmethod, param));
            Console.WriteLine(method.Name);
        }

        private void PropertyResolver(LambdaExpression expr, object[] param)
        {
            var prop = (MemberExpression)expr.Body;
            var propMember = (PropertyInfo)prop.Member;
            var method = propMember.GetSetMethod();
            this.Add(new Call(method, null, param));
            Console.WriteLine(method.Name);
        }
    }

非常感谢。 干杯!

Answer 1

所以你可以做两件事。一是确保 listOftypes 中的所有类型都派生自相同的基类，或实现相同的接口，在这种情况下，您可以只使用 where。

鉴于您的问题似乎表明这不是您想要的，您可以通过查看 typeof(T) 并查看该类型是否包含在 中，从而在运行时获得更好的错误报告类型列表。没有你想要的那么好，但你是有限的。

Answer 2

您无法执行您所要求的操作，例如：

where listOftypes.Contains(T)

但是您可以应用多种类型，但您确实需要将它们键入而不是按照您的建议维护集合。

有预定义的方法来应用约束：

其中 T：结构

类型参数必须是一个值
类型。除 Nullable 之外的任何值类型
可以指定。请参阅使用可空值
类型（C# 编程指南）了解更多信息
信息。

其中 T ：类

类型参数必须是引用
类型;这也适用于任何类别，
接口、委托或数组类型。

其中 T : new()

类型参数必须具有公共类型
无参数构造函数。使用时
与其他约束一起，
必须指定 new() 约束
最后。

其中 T ：

类型参数必须是或派生
来自指定的基类。

其中 T ：

类型参数必须是或实现
指定的接口。多种的
接口约束可以是
指定的。约束接口
也可以是通用的。

其中 T : U

为 T 提供的类型参数必须
是或源自论证
为美国供应。