匿名事件类

前段时间做匿名委托的时候发现了一些挺好玩的事情

如果我去遍历并执行一个List<Delegate>那么我可以自由的控制是否要执行我需要的步骤

比如说List{A，B，C，D，E}，A~E分别表示是否要去公园里某个景点，

那么我对这些事件进行穷举，然后来了客人甲，他只要告诉我他想要去的几个景点

我就可以给他安排路线（比如：执行顺序CDABE）要是临时取消或者想加个景点什么的也很方便

于是，为了使得列表里存放几乎任何形式上的方法，我选择使用Func<Object[], object>

但这样会产生一个问题，那就是当我加入到List中的Delegate假设并不是Func<Object[], object>的时候怎么办？

所以我还是选择使用Delegate来表示一切形式的委托，于是就套了一个Func<>壳

这样一来我可以把任意形式上Delegate丢进Func<>里，既有返回值也能接受值

所以就出现了这个结果

//这是一个列表

public static List<Func<object[], Delegate>> delegateList = new List<Func<object[], Delegate>>

{

//这是列表里的第一个元素，并且这是一个匿名委托，形式上是Func<object[], Delegate>

//useless，形式上是Func<object[], Delegate>里的object[]，不过没什么用，我还没找到必须要加这个的理由

(useless) =>
    {

//这是一个匿名委托，形式上是Delegate，这里的例子是Func<object[],object>，并不仅限于这个

Func<object[],object> function = (objs) =>
      {

//这里是返回值，形式上是Func<object[],object>里的object
        return new object();
      };

//这里是返回值，形式上是Func<in T, out TResult>中的out TResult这部分
      return function;
    },

//这是列表里的第二个元素

//这是一个匿名的委托

(useless)=>{ Func<object[],object> function = (objs) =>{return new object();};}，

//这是列表里的第三个元素

//这是一个Acion的委托

(useless)=>{ Action<object[]> function = (objs) =>{};}，
  };

public class MoeEvent
    {//新增一个方法，这个是插入，List里会多一个元素
        public void AddEvent(Func<object[], object> function)
        {
            if (function.GetType() == typeof(Func<object[], object>))
            {
                Func<object[], Delegate> f = (useless) => { return function; };
                MoeScript.delegateList.Add(f);
            }
        }//把function方法合并到某事件的前面，这个是多路广播，List里不会多出一个元素
        public void AddPrefixToEvent(int index, Func<object[], object> function)
        {
            if (index < MoeScript.delegateList.Count && index >= 0)
            {
                if (function.GetType() == typeof(Func<object[], object>) && MoeScript.delegateList[index].GetType() == typeof(Func<object[], Delegate>))
                {
                    Func<object[], object> oldfc = (Func<object[], object>)MoeScript.delegateList[index](new object[] { });
                    Func<object[], Delegate> fc = (useless) =>
                    {
                        Func<object[], object> newfc = function + oldfc;//区别在这里
                        return newfc;
                    };
                    MoeScript.delegateList[index] = fc;
                }
            }
        }//把function方法合并到某事件的后面，这个是多路广播，List里不会多出一个元素
        public void AddSuffixToEvent(int index, Func<object[], object> function)
        {
            if (index < MoeScript.delegateList.Count && index >= 0)
            {
                if (function.GetType() == typeof(Func<object[], object>) && MoeScript.delegateList[index].GetType() == typeof(Func<object[], Delegate>))
                {
                    Func<object[], object> oldfc = (Func<object[], object>)MoeScript.delegateList[index](new object[] { });
                    Func<object[], Delegate> fc = (useless) =>
                    {
                        Func<object[], object> newfc = oldfc + function;//区别在这里
                        return newfc;
                    };
                    MoeScript.delegateList[index] = fc;
                }
            }
        }
    }