C# 安全回调的异步处理的封装

 在窗口　load 里调用 AsyncTask.InitUIContext(); 初始化同步上下文

 

SwitchToUI  可以在多线程里切换到UI线程执行委托代码

AsyncSend  以阻塞模式执行回调

AsyncPost  以非阻塞模式执行回调

 

 

AsyncTask.AsyncPost<String>(() =>
{
    //在新的线程里执行
    return 获取网站源码？();
}, (v) =>
{
    //回到UI线程执行
    TextBox1.Text = v;
});

using System;
using System.Threading;

namespace Wpf.Model
{
    /// <summary>
    /// 异步任务 UI线程回调相关
    /// </summary>
    public static class AsyncTask
    {
        /// <summary>
        /// 线程同步上下文
        /// </summary>
        public static SynchronizationContext Context { get; private set; }

        /// <summary>
        /// UI线程ID
        /// </summary>
        public static Int32 mainThreadId { get; private set; }

        /// <summary>
        /// 初始化UI线程(只能在UI线程里初始化)
        /// </summary>
        public static void InitUIContext()
        {
            mainThreadId = Thread.CurrentThread.ManagedThreadId;
            Context = SynchronizationContext.Current;
        }

        /// <summary>
        /// 获取当前操作线程是否处于UI线程内
        /// </summary>
        public static Boolean IsUIThread
        {
            get
            {
                return Thread.CurrentThread.ManagedThreadId == mainThreadId;
            }
        }

        /// <summary>
        /// 提交到UI线程执行委托（异步）
        /// </summary>
        /// <param name="callback"></param>
        public static void PostToUI(Action callback)
        {
            try
            {
                if (Context == null)
                {
                    throw new Exception("SynchronizationContext.Current was not initialized");
                }
                if (AsyncTask.IsUIThread)
                {
                    callback();
                }
                else
                {
                    Context.Post((s) =>
                    {
                        callback();
                    }, null);
                }
            }
            catch (Exception ex)
            {
                LogHelper.energy.Error("AsyncTask.SwitchToUI=>" + ex.Message, ex);
            }
        }

        /// <summary>
        /// 切换到UI线程执行委托（同步）
        /// </summary>
        /// <param name="callback"></param>
        public static void SwitchToUI(Action callback)
        {
            try
            {
                if (Context == null)
                {
                    throw new Exception("SynchronizationContext.Current was not initialized");
                }
                if (AsyncTask.IsUIThread)
                {
                    callback();
                }
                else
                {
                    Context.Send((s) =>
                    {
                        callback();
                    }, null);
                }
            }
            catch (Exception ex)
            {
                LogHelper.energy.Error("AsyncTask.SwitchToUI=>" + ex.Message, ex);
            }
        }

        /// <summary>
        /// 异步执行委托,在完成后Send回调UI线程
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="asyncfunc">异步执行</param>
        /// <param name="completecallback">执行完成后回到当前线程回调</param>
        public static void AsyncSend<T>(Func<T> asyncfunc,Action<T> completecallback)
        {
            if (Context == null)
            {
                //当前是在UI线程内
                if (AsyncTask.IsUIThread)
                {
                    var result = asyncfunc();
                    completecallback((T)result);
                    //尝试初始化
                    InitUIContext();
                }
                else
                {
                    throw new Exception("SynchronizationContext.Current was not initialized");
                }
            }
            ThreadPool.QueueUserWorkItem((e) =>
            {
                try
                {
                    var result = asyncfunc();
                   
                    Context.Send((s) =>
                    {
                        completecallback((T)s);
                    }, result);
                }
                catch (Exception ex)
                {
                    LogHelper.energy.Error("AsyncTask.Async=>" + ex.Message, ex);
                }
            });
        }

        /// <summary>
        /// 异步执行委托,在完成后Post回调UI线程
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="asyncfunc">要异步执行的代码</param>
        /// <param name="completecallback">完成后Post执行的代码</param>
        public static void AsyncPost<T>(Func<T> asyncfunc, Action<T> completecallback)
        {
            if (Context == null)
            {
                //当前是在UI线程内
                if (AsyncTask.IsUIThread)
                {
                    var result = asyncfunc();
                    completecallback((T)result);
                    //尝试初始化
                    InitUIContext();
                }
                else
                {
                    throw new Exception("SynchronizationContext.Current was not initialized");
                }
            }
            ThreadPool.QueueUserWorkItem((e) =>
            {
                try
                {
                    var result = asyncfunc();

                    Context.Post((s) =>
                    {
                        completecallback((T)s);
                    }, result);
                }
                catch (Exception ex)
                {
                    LogHelper.energy.Error("AsyncTask.Async=>" + ex.Message, ex);
                }
            });
        }

        /// <summary>
        /// 异步执行 不是太紧急的任务
        /// </summary>
        /// <param name="asyncfunc"></param>
        public static void AsyncPost(Action asyncfunc)
        {
            if (asyncfunc != null)
            {
                ThreadPool.QueueUserWorkItem((e) =>
                {
                    try
                    {
                        asyncfunc();
                    }
                    catch (Exception ex)
                    {
                        LogHelper.energy.Error("AsyncTask.AsyncPost=>" + ex.Message, ex);
                    }
                });
            }
        }


    }
}