利用Lambda表达式、扩展方法以及泛型来为对象添加方法

问题1：

    public void AsycStartDispatcher(Dispatcher dispatcher)
    {
        var thread = new Thread(
                                (input) =>
                                {
                                    var dispatch = input as Dispatcher;
                                    if (dispatch != null) dispatch.Start();
                                });
        thread.Start(dispatcher);
    }

请考虑上面的代码，可以看到我们写了这么多行代码，其实只是完成了一件很简单的事，那就是在一个单独的线程中执行dispatch.Start()方法；那么有没有更好的方法呢，可不可以像下面这样只用一行就完成这个功能呢？

    public void AsycStartDispatcher(Dispatcher dispatcher)
    {
        dispatcher.AsycExec(obj => obj.Start());
    }

问题1解决方案：

　　如果我们利用Lambda表达式、扩展方法以及泛型来为对象添加一个方法就可以解决这个问题，具体代码如下：

    public static class ObjectExtensions
    {
        public static void AsycExec<T>(this T obj, Action<T> action)
        {
            action.BeginInvoke(obj, null, null);
        }
    }

　　不过在这里我们没有考虑线程异常的处理。

问题2：

    public void StartAllDispatcher(IEnumerable<Dispatcher> dispatchers)
    {
        foreach (var dispatcher in dispatchers)
        {
            dispatcher.Start();
        }
    }

    public void AsycStartAllDispatcher(IEnumerable<Dispatcher> dispatchers)
    {
        foreach (var dispatcher in dispatchers)
        {
            var thread = new Thread(
                                (input)
                                =>
                                {
                                    var dispatch = input as Dispatcher;
                                    if (dispatch != null) dispatch.Start();
                                });
            thread.Start(dispatcher);
        }
    }

　　对于上面的代码我们能不能不用Foreach而是直接对整个Enumerable对象执行一个方法呢？就下下面这样：

    public void TestForeach(IEnumerable<Dispatcher> dispatchers)
    {
        dispatchers.ExecEach(obj => obj.Start());

        dispatchers.AsycExecEach(obj => obj.Start());
    }

问题2解决方案：

    public static class ObjectExtensions
    {
        public static void ExecEach<T>(this IEnumerable<T> objs, Action<T> action)
        {
            foreach (var obj in objs)
            {
                action(obj);
            }
        }

        public static void AsycExecEach<T>(this IEnumerable<T> objs, Action<T> action)
        {
            foreach (var obj in objs)
            {
                action.BeginInvoke(obj, null, null);
            }
        }
    }

问题3：

    lock (s_ObjectCachePools)
    {
        if (!s_ObjectCachePools.ContainsKey(poolName))
        {
            s_ObjectCachePools.Add(poolName, new List<Object>());
        }

        s_ObjectCachePools[poolName].Add(result);
    }

   　对于上面的s_ObjectCachePools对象，每次操作都要使用lock (s_ObjectCachePools)语句，我们能不能有另一种写法呢？就像下面这样：

    s_ObjectCachePools.LockExec(objs =>
                {
                    if (!objs.ContainsKey(poolName))
                    {
                        objs.Add(poolName, new List<Object>());
                    }

                    objs[poolName].Add(result);
                });

问题3解决方案：

    public static class ObjectExtensions
    {
        public static void LockExec<T>(this T obj, Action<T> action) where T : class
        {
            lock (obj)
            {
                action(obj);
            }
        }
    }

总的解决方案

    public static class ObjectExtensions
    {
        public static void Exec<T>(this T obj, Action<T> action)
        {
            action(obj);
        }

        public static void AsycExec<T>(this T obj, Action<T> action)
        {
            action.BeginInvoke(obj,null,null);
        }

        public static void ExecEach<T>(this IEnumerable<T> objs, Action<T> action)
        {
            foreach (var obj in objs)
            {
                action(obj);
            }
        }

        public static void AsycExecEach<T>(this IEnumerable<T> objs, Action<T> action)
        {
            foreach (var obj in objs)
            {
                action.BeginInvoke(obj,null,null);
            }
        }

        public static void LockExec<T>(this T obj, Action<T> action) where T:class 
        {
            lock (obj)
            {
                action(obj); 
            }
        }
    }