委托方法列表里面方法随机执行其中一个

Question

可以使用Random，用得到的随机数作为key来匹配不同的算法

Answer 1

    public delegate void test();
    class Class1
    {
        public event test testclick;
        public Class1()
        {
            testclick += A;
            testclick += B;
        }
        public void A(){}
        public void B(){}
        public static T GetEventHandler<T>(object classInstance, string eventName)
        {
            Type classType = classInstance.GetType();
            FieldInfo eventField = classType.GetField(eventName, BindingFlags.GetField
                                                               | BindingFlags.NonPublic
                                                               | BindingFlags.Instance);
            var eventDelegate = (T)eventField.GetValue(classInstance);
            return eventDelegate;
        }
    }    public class TestClass
    {
        public object InvokeMethod(bool needrandom,params object[] p_Objects)
        {
            object result = null;
            var classs = new Class1();
            var eventDelegate = Class1.GetEventHandler<test>(classs, "testclick");
            var eventlist = eventDelegate.GetInvocationList();
            if (needrandom)
            {
                var rd=new Random();
                var index=rd.Next(0, eventlist.Length);
                result = eventlist[index].DynamicInvoke(p_Objects);
            }
            else
            {
                foreach (var eventMethod in eventlist)
                {
                    result = eventMethod.DynamicInvoke(p_Objects);
                }
            }
            return result;
        }
    }

Answer 2

params object[] p_Objects，这里的p_Objects,需要传递什么参数才能执行该方法？

Answer 3

委托链本身就会连续调用，如果三个方法可以访问同一个公有变量，那还可以实现随机调用某个，然后通过另一个全局变量返回值
（最后一个被委托的方法在真正执行的那个方法结束之前，必须被阻塞等待）不过话说回来，如果这不是无可奈何的事情，那就换个思路
为啥一定要用委托链来实现这种需求？为啥不能通过List<Func<>>加随机数的方式来实现你的需求？

Answer 4

params object[] p_Objects，这里的p_Objects,需要传递什么参数才能执行该方法？
p_Objects是一个可以传变长参数的参数组，
比如你要执行的方法是2个参数 (string id,int count)
就调用TestClass testclass=new TestClass();
testclass.InvokeMethod(true,id,count);

Answer 5

如果只是委托，你随便可离散调用它。例如对于public class TA
{
    public delegate void ABC(string x, int b);    public ABC abc;    public void test()
    {
        if (abc != null)
            abc(DateTime.Now.ToString(), DateTime.Now.Second);
    }
}
你就可以这样调用var x = new TA();
x.abc += (p1, p2) =>
{
    Console.WriteLine("rule1");
};
x.abc += (p1, p2) =>
{
    Console.WriteLine("rule2");
};
x.abc += (p1, p2) =>
{
    Console.WriteLine("rule3");
};
var array = x.abc.GetInvocationList();
((TA.ABC)array[2])("1213", 1);
((TA.ABC)array[0])("1213", 1);
这里按照3、1的次序调用它。其实这就是事件跟普通的委托的区别。如果你声明为public event ABC abc;那么就不允许在 TA 类型外部去散列 abc 委托了，你就只能在 TA 内部去实现。例如写public void test(int index)
{
    var x = (ABC)abc.GetInvocationList()[index];
    if (x != null)
        x(DateTime.Now.ToString(), DateTime.Now.Second);
}

Answer 6

这里，你要理解委托跟事件概念上的区别（他们并不是对立的，但是是不同层次的）。另外还要理解 GetInvocationList 方法的知识。最后要注意，不要随便反射，要使用接口、继承、重构等知识来设计的程序。从性能、可维护性、稳定性上去考虑，稍多使用它也是有害的。