C#实现线程管理类

已于 2022-07-28 20:57:29 修改
阅读量913 收藏 4
点赞数
分类专栏： C# 文章标签： c# ui 开发语言
于 2022-07-28 20:54:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglianzhu_91/article/details/126043598
版权

在开发winform时候为了体验好，一般可以把长时间任务用线程执行。但是大多数情况是有多个费事操作需要执行。如果每个都开启线程的话。那么多个线程之间又是乱序执行的。很多业务需要按先后顺序执行。但又需要不卡UI。为此我在14年时候开发了线程管理类，用来管理线程执行。

源码

管理类基于BackgroundWorker类和队列实现。BackgroundWorker想了解的自己查文档。

实现如下：

///作者：张联珠
///日期：2014-03-01
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Reflection;
using System.Windows.Forms;

namespace Util
{
    #region 异步工具调用前初始化的委托
    /// <summary>
    /// 初始化异步工具的委托
    /// </summary>
    /// <param name="backGroundWorker">BackgroundWorker</param>
    public delegate void InitAsyUtil(BackgroundWorker backGroundWorker);
    #endregion

    #region 单线程时的后台执行者
    ///<summary  NoteObject="Class">
    /// [功能描述:内部的后台工作对象，如果要使后台有序，几个工具类都把任务交给该对象] <para/>
    /// [创建者:张联珠] <para/>
    /// [创建时间:2014年4月11日] <para/>
    ///<说明>
    ///  [说明:修改原工具类
    ///  使用说明：后台操作方法不要访问UI资源]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public static class InnerBackGroundWorker
    {
        /// <summary>
        /// 私有的静态工作对象
        /// </summary>
        private static BackgroundWorker SelfBackgroundWorker = new BackgroundWorker();

        /// <summary>
        /// 后台队列
        /// </summary>
        private static Queue<object[]> WaiteQueue = new Queue<object[]>();

        /// <summary>
        /// 调用锁
        /// </summary>
        public static object Lock = new object();

        /// <summary>
        /// 运行一个任务,如果线程正忙，任务进入等待
        /// </summary>
        /// <param name="objs"></param>
        public static void RunWorkerAsync(object [] objs)
        {
           lock (WaiteQueue)
           {
            //如果后台正忙，进入队列等待
            if (SelfBackgroundWorker.IsBusy || WaiteQueue.Count > 0)
            {
                    WaiteQueue.Enqueue(objs);
            }
            else
            {
                InitAsyUtil initAsyUitil = objs[4] as InitAsyUtil;
                SelfBackgroundWorker = new BackgroundWorker();
                initAsyUitil(SelfBackgroundWorker);
                SelfBackgroundWorker.RunWorkerAsync(objs);
            }
           }
        }

        /// <summary>
        /// 运行任务结束时执行，如果队列没有等待的任务，什么也不做，否则执行下一条任务
        /// </summary>
        /// <param name="objs"></param>
        public static void RunWorkerAsync()
        {
            lock (WaiteQueue)
            {
                //如果队列中有等待
                if (!SelfBackgroundWorker.IsBusy && WaiteQueue.Count > 0)
                {
                    object[] objs = null;
                    objs = WaiteQueue.Dequeue();
                    SelfBackgroundWorker = new BackgroundWorker();
                    InitAsyUtil initAsyUitil = objs[4] as InitAsyUtil;
                    initAsyUitil(SelfBackgroundWorker);
                    SelfBackgroundWorker.RunWorkerAsync(objs);
                }
            }
        }
    }
    #endregion

    #region 带返回类型的异步工具
    ///<summary  NoteObject="Class">
    /// [功能描述:管理的异步工具类] <para/>
    /// [创建者:张联珠] <para/>
    /// [创建时间:2014年4月11日] <para/>
    ///<说明>
    ///  [说明:修改原工具类
    ///  使用说明：后台操作方法不要访问UI资源]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public static class ManagedAsyncUtils<TResult>
    {
        /// <summary>
        /// 私有的静态工作对象
        /// </summary>
        private static BackgroundWorker SelfBackgroundWorker = null;


        /// <summary>
        /// 使用前出师化异步工具
        /// </summary>
        private static void InitUtil(BackgroundWorker backGroundWorker)
        {
            SelfBackgroundWorker = backGroundWorker;
            SelfBackgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork);
            SelfBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
        }


        /// <summary>
        /// 异步调用
        /// </summary>
        /// <param name="invokeCompleted">回调方法委托()回调的方法可以不是公有的，因为使用委托了</param>
        /// <param name="businessObject">调用目标对象实例（后台方法所在类的对象）</param>
        /// <param name="methodName">后台执行的方法名称（要申明成公有，应为内部通过反射来访问，不是公有的话会访问不到。该操作方法不要访问UI资源，在回调方法里访问）</param>
        /// <param name="args">后台执行方法需要的参数（和参数顺序一样的object数组）</param>
        /// <param name="isSelfAsy">是否单独一个异步</param>
        public static void Invoke(Action<TResult, Exception> invokeCompleted, object businessObject,
            string methodName, object[] args,bool isSelfAsy=false)
        {
            if (!isSelfAsy)
            {
                lock (InnerBackGroundWorker.Lock)
                {
                    InnerBackGroundWorker.RunWorkerAsync(new object[] { invokeCompleted, businessObject, methodName, args, new InitAsyUtil(InitUtil), isSelfAsy });
                }
            }
            else
            {
                InitUtil(new BackgroundWorker());
                SelfBackgroundWorker.RunWorkerAsync(new object[] { invokeCompleted, businessObject, methodName, args, new InitAsyUtil(InitUtil), isSelfAsy });
            }
        }

        /// <summary>
        /// BackgroundWorker的后台方法
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">参数</param>
        private static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            //获得参数数组
            var arguments = e.Argument as object[];
            //获得回调方法
            var completeMethod = arguments[0];
            //获得业务实体
            var businessObject = arguments[1];
            //获得方法名
            var methodName = arguments[2] as string;
            //获得参数
            var args = arguments[3] as object[];
            //存放结果
            object result = null;
            //存放异常
            Exception ex = null;
            try
            {
                //参数类型集合
                List<Type> lstArgType = new List<Type>();
                //把所有参数的类型填入集合
                if (args != null && args.Length > 0)
                {
                    for (int i = 0; i < args.Length; i++)
                    {
                        lstArgType.Add(args[i].GetType());
                    }
                }
                //获得方法
                var method = GetTarMethod(businessObject.GetType(), methodName, lstArgType.ToArray());
                //如果没找到该方法，直接执行该业务实体的方法
                if (method == null)
                {
                    //执行，并把结果赋给结果对象
                    result = businessObject.GetType().GetMethod(methodName, lstArgType.ToArray()).Invoke(businessObject, args);
                }
                //如果找到了方法，则通过接口调方法
                else
                {
                    result = method.Invoke(businessObject, args);
                }
            }
            catch (Exception exThread)
            {
                ex = exThread;
            }
            //结果由参数带回
            e.Result = new object[] { result, completeMethod, ex, arguments[5] };
        }   

        /// <summary>
        /// 回调方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var results = e.Result as object[];
            //取出结果
            var result = results[0];
            Exception ex = null;
            //如果结果带出的异常不为空
            if (results[2] != null)
            {
                var exThread = results[2] as Exception;
                //如果内部异常不为空，则取内部异常
                if (exThread.InnerException != null)
                {
                    ex = exThread.InnerException;
                }
                //否则直接取总异常
                else
                {
                    ex = exThread;
                }
            }
            try
            {
                //取出回调委托
                Action<TResult, Exception> method = results[1] as Action<TResult, Exception>;
                //如果返回结果为空，传该类型的默认值
                if (result == null)
                {
                    method(default(TResult), ex);
                }
                //否则传带出的结果
                else
                {
                    method((TResult)result, ex);
                }
            }
            //应对回调时回调对象已被销毁
            catch (Exception exc)
            {
                //把除了访问已释放的资源异常吃掉外，其他异常抛出，方便调试
                if (!(exc is ObjectDisposedException))
                {
                    throw exc;
                }
            }
            finally
            {
                //及时清除引用，防止以后错误调用的干扰
                SelfBackgroundWorker = null;
                if(!((bool)results[3]))
                {
                InnerBackGroundWorker.RunWorkerAsync();
                }
            }
        }

        /// <summary>
        /// 获得目标方法
        /// </summary>
        /// <param name="svcType">方法所在类型</param>
        /// <param name="methodName">方法名</param>
        /// <param name="argTypes">参数类型集合</param>
        /// <returns>方法信息</returns>
        private static MethodInfo GetTarMethod(Type svcType, string methodName, Type[] argTypes)
        {
            //获取由当前实体所实现的接口集合
            foreach (var item in svcType.GetInterfaces())
            {
                //通过名称和类型找方法
                var method = item.GetMethod(methodName, argTypes);
                //找到方法就返回
                if (method != null)
                {
                    return method;
                }
            }
            return null;
        }

    }
    #endregion

    #region 不带返回类型的异步工具
    ///<summary  NoteObject="Class">
    /// [功能描述:管理的异步工具类] <para/>
    /// [创建者:张联珠] <para/>
    /// [创建时间:2014年4月11日] <para/>
    ///<说明>
    ///  [说明:修改原工具类
    ///  使用说明：后台操作方法不要访问UI资源]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public static class ManagedAsyncUtils
    {
        /// <summary>
        /// 私有的静态工作对象
        /// </summary>
        private static BackgroundWorker SelfBackgroundWorker = null;


        /// <summary>
        /// 使用前初始化异步工具
        /// </summary>
        public static void InitUtil(BackgroundWorker backGroundWorker)
        {
            SelfBackgroundWorker = backGroundWorker;
            SelfBackgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork);
            SelfBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
        }

        /// <summary>
        /// 异步调用
        /// </summary>
        /// <param name="invokeCompleted">回调方法委托()回调的方法可以不是公有的，因为使用委托了</param>
        /// <param name="businessObject">调用目标对象实例（后台方法所在类的对象）</param>
        /// <param name="methodName">后台执行的方法名称（要申明成公有，应为内部通过反射来访问，不是公有的话会访问不到。该操作方法不要访问UI资源，在回调方法里访问）</param>
        /// <param name="args">后台执行方法需要的参数（和参数顺序一样的object数组）</param>
        /// <param name="isSelfAsy">是否单独一个异步</param>
        public static void Invoke(Action<Exception> invokeCompleted, object businessObject,
            string methodName,object[] args,bool isSelfAsy=false)
        {
            if (!isSelfAsy)
            {
                lock (InnerBackGroundWorker.Lock)
                {
                    InnerBackGroundWorker.RunWorkerAsync(new object[] { invokeCompleted, businessObject, methodName, args, new InitAsyUtil(InitUtil), isSelfAsy });
                }
            }
            else
            {
                InitUtil(new BackgroundWorker());
                SelfBackgroundWorker.RunWorkerAsync(new object[] { invokeCompleted, businessObject, methodName, args, new InitAsyUtil(InitUtil), isSelfAsy });
            }
        }

        /// <summary>
        /// 后台工作方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            //提出方法参数
            var arguments = e.Argument as object[];
            //提出回调委托
            var completeMethod = arguments[0];
            //提出调用方法的对象
            var businessObject = arguments[1];
            //提出调用方法的名称
            var methodName = arguments[2] as string;
            //提出调用方法的参数
            var args = arguments[3] as object[];
            //异常
            Exception ex = null;
            try
            {
                //存所有的参数类型
                List<Type> lstArgType = new List<Type>();
                if (args != null && args.Length > 0)
                {
                    for (int i = 0; i < args.Length; i++)
                    {
                        lstArgType.Add(args[i].GetType());
                    }
                }
                //获得调用方法
                var method = GetTarMethod(businessObject.GetType(), methodName, lstArgType.ToArray());
                if (method == null)
                {
                    businessObject.GetType().GetMethod(methodName, lstArgType.ToArray()).Invoke(businessObject, args);
                }
                else
                {
                    method.Invoke(businessObject, args);
                }
            }
            catch (Exception exThread)
            {
                ex = exThread;
            }
            //结果由参数带回
            e.Result = new object[] { completeMethod, ex, arguments[5] };
        }

        /// <summary>
        /// 获得目标方法
        /// </summary>
        /// <param name="svcType">方法所在类型</param>
        /// <param name="methodName">方法名</param>
        /// <param name="argTypes">参数类型集合</param>
        /// <returns>方法信息</returns>
        private static MethodInfo GetTarMethod(Type svcType, string methodName, Type[] argTypes)
        {
            foreach (var item in svcType.GetInterfaces())
            {
                var method = item.GetMethod(methodName, argTypes);
                if (method != null)
                {
                    return method;
                }
            }
            return null;
        }

        /// <summary>
        /// 回调方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            //取出结果
            var results = e.Result as object[];
            try
            {
                //取出回调方法
                var method = results[0] as Action<Exception>;
                if (results[1] != null)
                {
                    var exThread = results[1] as Exception;
                    if (exThread.InnerException != null)
                    {
                        method(exThread.InnerException);
                    }
                    else
                    {
                        method(exThread);
                    }
                }
                else
                {
                    method(null);
                }
            }
            //应对回调时回调对象已被销毁
            catch (Exception exc)
            {
                //把除了访问已释放的资源异常吃掉外，其他异常抛出，方便调试
                if (!(exc is ObjectDisposedException))
                {
                    throw exc;
                }
            }
            finally
            {
                //及时清除引用，防止以后错误调用的干扰
                SelfBackgroundWorker = null;
                if (!((bool)results[2]))
                {
                    InnerBackGroundWorker.RunWorkerAsync();
                }
            }
        }
    }
    #endregion

    #region 带返回类型的异步工具-含报告
    ///<summary  NoteObject="Class">
    /// [功能描述:管理的带报告带返回值的异步工具类，对于调用异步时使用单独线程的操作就千万不要调用Report方法，因为单独线程已经不处于托管环境了，此时调Report会干扰托管的线程] <para/>
    /// [创建者:张联珠] <para/>
    /// [创建时间:2014年4月11日] <para/>
    ///<说明>
    ///  [说明:修改原工具类
    ///  使用说明：后台操作方法不要访问UI资源]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public static class ManagedAsyncUtilsWithReport<TResult, TReport>
    {
        #region 字段
        /// <summary>
        /// 私有的静态工作对象
        /// </summary>
        private static BackgroundWorker SelfBackgroundWorker = null;

        /// <summary>
        /// 通知回调
        /// </summary>
        private static Action<TReport, Exception> Reports;
        #endregion

        #region 构造函数

        /// <summary>
        /// 使用前初始化异步工具
        /// </summary>
        public static void InitUtil(BackgroundWorker backGroundWorker)
        {
            SelfBackgroundWorker = backGroundWorker;
            SelfBackgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork);
            SelfBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
            SelfBackgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
            //支持报告进度
            SelfBackgroundWorker.WorkerReportsProgress = true;
        }
        #endregion

        #region 对外提供的方法
        /// <summary>
        /// 异步调用
        /// </summary>
        /// <param name="invokeCompleted">回调方法委托()回调的方法可以不是公有的，因为使用委托了</param>
        /// <param name="reportChanged">通知改变的回调方法委托(该参数可以为空，为空就不通知改变,如果传入该参数不为空，可以调用Report方法来反信息)回调的方法可以不是公有的，因为使用委托了</param>
        /// <param name="businessObject">调用目标对象实例（后台方法所在类的对象）</param>
        /// <param name="methodName">后台执行的方法名称（要申明成公有，应为内部通过反射来访问，不是公有的话会访问不到。该操作方法不要访问UI资源，在回调方法里访问）</param>
        /// <param name="args">后台执行方法需要的参数（和参数顺序一样的object数组）</param>
        /// <param name="isSelfAsy">是否单独一个异步</param>
        public static void Invoke(Action<TResult, Exception> invokeCompleted, Action<TReport, Exception> reportChanged, object businessObject,
            string methodName, object[] args, bool isSelfAsy = false)
        {
            if (!isSelfAsy)
            {
                lock (InnerBackGroundWorker.Lock)
                {
                    InnerBackGroundWorker.RunWorkerAsync(new object[] { invokeCompleted, businessObject, methodName, args, new InitAsyUtil(InitUtil), reportChanged, isSelfAsy });
                }
            }
            else
            {
                InitUtil(new BackgroundWorker());
                SelfBackgroundWorker.RunWorkerAsync(new object[] { invokeCompleted, businessObject, methodName, args, new InitAsyUtil(InitUtil), reportChanged, isSelfAsy });
            }
        }

        /// <summary>
        /// 报告事件
        /// </summary>
        /// <param name="reportInfo">报告内容</param>
        /// <param name="ex">报告异常</param>
        public static void Report(TReport reportInfo, Exception ex)
        {
            object[] args = new object[] { reportInfo, ex };
            SelfBackgroundWorker.ReportProgress(0, args);
        }

        #endregion

        #region 内部方法

        /// <summary>
        /// BackgroundWorker的后台方法
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">参数</param>
        private static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            //获得参数数组
            var arguments = e.Argument as object[];
            //获得回调方法
            var completeMethod = arguments[0];
            //获得业务实体
            var businessObject = arguments[1];
            //获得方法名
            var methodName = arguments[2] as string;
            //获得参数
            var args = arguments[3] as object[];
            //通知回调
            Reports = arguments[5] as Action<TReport, Exception>;
            //存放结果
            object result = null;
            //存放异常
            Exception ex = null;
            try
            {
                //参数类型集合
                List<Type> lstArgType = new List<Type>();
                //把所有参数的类型填入集合
                if (args != null && args.Length > 0)
                {
                    for (int i = 0; i < args.Length; i++)
                    {
                        lstArgType.Add(args[i].GetType());
                    }
                }
                //获得方法
                var method = GetTarMethod(businessObject.GetType(), methodName, lstArgType.ToArray());
                //如果没找到该方法，直接执行该业务实体的方法
                if (method == null)
                {
                    //执行，并把结果赋给结果对象
                    result = businessObject.GetType().GetMethod(methodName, lstArgType.ToArray()).Invoke(businessObject, args);
                }
                //如果找到了方法，则通过接口调方法
                else
                {
                    result = method.Invoke(businessObject, args);
                }
            }
            catch (Exception exThread)
            {
                ex = exThread;
            }
            //结果由参数带回
            e.Result = new object[] { result, completeMethod, ex, arguments[6] };
        }

        /// <summary>
        /// 回调方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var results = e.Result as object[];
            //取出结果
            var result = results[0];
            Exception ex = null;
            //如果结果带出的异常不为空
            if (results[2] != null)
            {
                var exThread = results[2] as Exception;
                //如果内部异常不为空，则取内部异常
                if (exThread.InnerException != null)
                {
                    ex = exThread.InnerException;
                }
                //否则直接取总异常
                else
                {
                    ex = exThread;
                }
            }
            try
            {
                //取出回调委托
                Action<TResult, Exception> method = results[1] as Action<TResult, Exception>;
                //如果返回结果为空，传该类型的默认值
                if (result == null)
                {
                    method(default(TResult), ex);
                }
                //否则传带出的结果
                else
                {
                    method((TResult)result, ex);
                }
            }
            //应对回调时回调对象已被销毁
            catch (Exception exc)
            {
                //把除了访问已释放的资源异常吃掉外，其他异常抛出，方便调试
                if (!(exc is ObjectDisposedException))
                {
                    throw exc;
                }
            }
            finally
            {
                //及时清除引用，防止以后错误调用的干扰
                SelfBackgroundWorker = null;
                if(!((bool)results[3]))
                {
                    InnerBackGroundWorker.RunWorkerAsync();
                }
            }
        }


        /// <summary>
        /// 进度改变事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            //如果通知回调不为空
            if (Reports != null)
            {
                //提出方法参数
                var arguments = e.UserState as object[];
                Reports((TReport)arguments[0], arguments[1] as Exception);
            }
        }

        /// <summary>
        /// 获得目标方法
        /// </summary>
        /// <param name="svcType">方法所在类型</param>
        /// <param name="methodName">方法名</param>
        /// <param name="argTypes">参数类型集合</param>
        /// <returns>方法信息</returns>
        private static MethodInfo GetTarMethod(Type svcType, string methodName, Type[] argTypes)
        {
            //获取由当前实体所实现的接口集合
            foreach (var item in svcType.GetInterfaces())
            {
                //通过名称和类型找方法
                var method = item.GetMethod(methodName, argTypes);
                //找到方法就返回
                if (method != null)
                {
                    return method;
                }
            }
            return null;
        }
        #endregion

    }


    #endregion

    #region 不带返回类型的异步工具-含报告
    ///<summary  NoteObject="Class">
    /// [功能描述:管理的的带报告的异步工具类,对于调用异步时使用单独线程的操作就千万不要调用Report方法，因为单独线程已经不处于托管环境了，此时调Report会干扰托管的线程] <para/>
    /// [创建者:张联珠] <para/>
    /// [创建时间:2014年4月11日] <para/>
    ///<说明>
    ///  [说明:修改原工具类
    ///  使用说明：后台操作方法不要访问UI资源]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public static class ManagedAsyncUtilsWithReport<TReport>
    {
        #region 字段
        /// <summary>
        /// 私有的静态工作对象
        /// </summary>
        private static BackgroundWorker SelfBackgroundWorker = null;

        /// <summary>
        /// 通知回调
        /// </summary>
        private static Action<TReport, Exception> Reports;

        #endregion

        #region 构造函数

        /// <summary>
        /// 使用前初始化异步工具
        /// </summary>
        public static void InitUtil(BackgroundWorker backGroundWorker)
        {
            SelfBackgroundWorker = backGroundWorker;
            SelfBackgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork);
            SelfBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
            SelfBackgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
            //支持报告进度
            SelfBackgroundWorker.WorkerReportsProgress = true;
        }
        #endregion

        #region 对外提供的方法

        /// <summary>
        /// 异步调用
        /// </summary>
        /// <param name="invokeCompleted">回调方法委托()回调的方法可以不是公有的，因为使用委托了</param>
        /// <param name="reportChanged">通知改变的回调方法委托(该参数可以为空，为空就不通知改变,如果传入该参数不为空，可以调用Report方法来反信息)回调的方法可以不是公有的，因为使用委托了</param>
        /// <param name="businessObject">调用目标对象实例（后台方法所在类的对象）</param>
        /// <param name="methodName">后台执行的方法名称（要申明成公有，应为内部通过反射来访问，不是公有的话会访问不到。该操作方法不要访问UI资源，在回调方法里访问）</param>
        /// <param name="args">后台执行方法需要的参数（和参数顺序一样的object数组）</param>
        /// <param name="isSelfAsy">是否单独一个异步</param>
        public static void Invoke(Action<Exception> invokeCompleted, Action<TReport, Exception> reportChanged, object businessObject,
            string methodName, object[] args, bool isSelfAsy=false)
        {
            if (!isSelfAsy)
            {
                lock (InnerBackGroundWorker.Lock)
                {
                    InnerBackGroundWorker.RunWorkerAsync(new object[] { invokeCompleted, businessObject, methodName, args, new InitAsyUtil(InitUtil),reportChanged, isSelfAsy });
                }
            }
            else
            {
                InitUtil(new BackgroundWorker());
                SelfBackgroundWorker.RunWorkerAsync(new object[] { invokeCompleted, businessObject, methodName, args, new InitAsyUtil(InitUtil),reportChanged ,isSelfAsy });
            }
        }

        /// <summary>
        /// 报告事件
        /// </summary>
        /// <param name="reportInfo">报告内容</param>
        /// <param name="ex">报告异常</param>
        public static void Report(TReport reportInfo, Exception ex)
        {
            object[] args = new object[] { reportInfo, ex };
            SelfBackgroundWorker.ReportProgress(0, args);
        }
        #endregion

        #region 内部方法

        /// <summary>
        /// 后台工作方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            //提出方法参数
            var arguments = e.Argument as object[];
            //提出回调委托
            var completeMethod = arguments[0];
            //提出调用方法的对象
            var businessObject = arguments[1];
            //提出调用方法的名称
            var methodName = arguments[2] as string;
            //提出调用方法的参数
            var args = arguments[3] as object[];
            //通知回调
            Reports = arguments[5] as Action<TReport, Exception>;
            //异常
            Exception ex = null;
            try
            {
                //存所有的参数类型
                List<Type> lstArgType = new List<Type>();
                if (args != null && args.Length > 0)
                {
                    for (int i = 0; i < args.Length; i++)
                    {
                        lstArgType.Add(args[i].GetType());
                    }
                }
                //获得调用方法
                var method = GetTarMethod(businessObject.GetType(), methodName, lstArgType.ToArray());
                if (method == null)
                {
                    businessObject.GetType().GetMethod(methodName, lstArgType.ToArray()).Invoke(businessObject, args);
                }
                else
                {
                    method.Invoke(businessObject, args);
                }
            }
            catch (Exception exThread)
            {
                ex = exThread;
            }
            //结果由参数带回
            e.Result = new object[] { completeMethod, ex, arguments[6] };
        }

        /// <summary>
        /// 获得目标方法
        /// </summary>
        /// <param name="svcType">方法所在类型</param>
        /// <param name="methodName">方法名</param>
        /// <param name="argTypes">参数类型集合</param>
        /// <returns>方法信息</returns>
        private static MethodInfo GetTarMethod(Type svcType, string methodName, Type[] argTypes)
        {
            foreach (var item in svcType.GetInterfaces())
            {
                var method = item.GetMethod(methodName, argTypes);
                if (method != null)
                {
                    return method;
                }
            }
            return null;
        }



        /// <summary>
        /// 进度改变事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            //如果通知回调不为空
            if (Reports != null)
            {
                //提出方法参数
                var arguments = e.UserState as object[];
                Reports((TReport)arguments[0], arguments[1] as Exception);
            }
        }

        /// <summary>
        /// 回调方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            //取出结果
            var results = e.Result as object[];
            try
            {
                //取出回调方法
                var method = results[0] as Action<Exception>;
                if (results[1] != null)
                {
                    var exThread = results[1] as Exception;
                    if (exThread.InnerException != null)
                    {
                        method(exThread.InnerException);
                    }
                    else
                    {
                        method(exThread);
                    }
                }
                else
                {
                    method(null);
                }
            }
            //应对回调时回调对象已被销毁
            catch(Exception exc)
            {
                //把除了访问已释放的资源异常吃掉外，其他异常抛出，方便调试
                if (!(exc is ObjectDisposedException))
                {
                    throw exc;
                }
            }
            finally
            {
                //及时清除引用，防止以后错误调用的干扰
                SelfBackgroundWorker = null;
                if (!((bool)results[2]))
                {
                    InnerBackGroundWorker.RunWorkerAsync();
                }
            }
        }

        #endregion
    }
    #endregion
   
}

这样就可以把需要线程执行的逻辑交给管理类执行了。还是上一篇线程的例子接着写。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using Util;

namespace ThreadUI
{
    /// <summary>
    /// 写日志委托
    /// </summary>
    /// <param name="info"></param>
    public delegate void WriteInfoDelegate(string info);

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 加载方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_Load(object sender, EventArgs e)
        {
            //用线程写文本
            //Thread t = new Thread(WriteTxt);
            //t.Start();
            //创建异步工具类的回调委托
            Action<Exception> workerCompleted = new Action<Exception>(DealReturn);
            //创建异步工具类的回调委托
            Action<LogDto, Exception> workerCahnge = new Action<LogDto, Exception>(DealChange);
            //组装参数
            object[] paras = new object[] { };
            //初始化工具
            ManagedAsyncUtilsWithReport<LogDto>.InitUtil(new BackgroundWorker());
            //这里启动的线程是被管理的，多个调用之间是先后执行的。用来实现UI即需要线程，又不希望线程之间乱序执行
            ManagedAsyncUtilsWithReport<LogDto>.Invoke(workerCompleted, workerCahnge, this, "StartMonitor", paras);
            ManagedAsyncUtilsWithReport<LogDto>.Invoke(workerCompleted, workerCahnge, this, "StartMonitor1", paras);

        }

        /// <summary>
        /// 开始监听
        /// </summary>
        public void StartMonitor()
        {
            //循环通知界面
            for (int i = 0; i < 100; i++)
            {
                LogDto dt = new LogDto();
                dt.Time = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");
                dt.Info = "第" + i + "行\n";
                ManagedAsyncUtilsWithReport<LogDto>.InitUtil(new BackgroundWorker());
                //通知界面改变
                ManagedAsyncUtilsWithReport<LogDto>.Report(dt, null);
            }
        }

        /// <summary>
        /// 开始监听
        /// </summary>
        public void StartMonitor1()
        {
            //循环通知界面
            for (int i = 101; i < 200; i++)
            {
                LogDto dt = new LogDto();
                dt.Time = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");
                dt.Info = "第" + i + "行\n";
                ManagedAsyncUtilsWithReport<LogDto>.InitUtil(new BackgroundWorker());
                //通知界面改变
                ManagedAsyncUtilsWithReport<LogDto>.Report(dt, null);
            }
        }

        /// <summary>
        /// 处理数据改变
        /// </summary>
        /// <param name="ex">异常信息</param>
        public void DealChange(LogDto dto, Exception ex)
        {
            string log = dto.Time + " " + dto.Info;
            //组装参数
            object[] paras = new object[] { log };
            //在UI线程执行委托
            this.Invoke(new WriteInfoDelegate(SetTxt), paras);
        }

        /// <summary>
        /// 处理返回的回调
        /// </summary>
        /// <param name="ex"></param>
        public void DealReturn(Exception ex)
        {
            richTextBox1.Text += "运行一轮完毕!\n";
            //创建异步工具类的回调委托
            //Action<Exception> workerCompleted = new Action<Exception>(DealReturn);
            //创建异步工具类的回调委托
            //Action<LogDto, Exception> workerCahnge = new Action<LogDto, Exception>(DealChange);
            //组装参数
            //object[] paras = new object[] { };
            //初始化工具
            //ManagedAsyncUtilsWithReport<LogDto>.InitUtil(new BackgroundWorker());
            //ManagedAsyncUtilsWithReport<LogDto>.Invoke(workerCompleted, workerCahnge, this, "StartMonitor", paras);
        }

        /// <summary>
        /// 写日志代理方法
        /// </summary>
        /// <param name="info"></param>
        public void WriteInfoProxy(string info)
        {
            //组装参数
            object[] paras = new object[] { info };
            //在UI线程执行委托
            this.Invoke(new WriteInfoDelegate(SetTxt), paras);
        }

        /// <summary>
        /// 操作控件逻辑
        /// </summary>
        /// <param name="info"></param>
        public void SetTxt(string info)
        {
            richTextBox1.Text += info;
        }

        /// <summary>
        /// 写文本
        /// </summary>
        public void WriteTxt()
        {
            for (int i = 0; i < 100; i++)
            {
                WriteInfoProxy("第" + i + "行\n");
            }

        }

        /// [功能描述: 监听日志实体，用来存监听的日志数据]<br></br>
        /// [创建者:   张联珠]<br></br>
        /// [创建时间: 2015-7-9]<br></br>
        /// <说明>
        ///    
        /// </说明>
        /// <修改记录>
        ///     <修改时间></修改时间>
        ///     <修改内容>
        ///            
        ///     </修改内容>
        /// </修改记录>
        /// </summary>
        [Serializable]
        public class LogDto
        {
            /// <summary>
            /// 时间
            /// </summary>
            public string Time
            {
                get;
                set;
            }


            /// <summary>
            /// 信息
            /// </summary>
            public string Info
            {
                get;
                set;
            }
        }

    }
}

在图的地方开启了两个线程，如果不管理线程，那么第一个线程输出的1-100和第二个线程输出的100-200肯定有重叠了。管理之后就不会重叠了。
在这里插入图片描述

在这里插入图片描述

这就是线程管理类的妙处了，既保证不卡UI，又保证线程之间有序性。

iMedicalLIS监听程序的异步就是基于线程管理类构建的，没有之间创建Thread。此逻辑稳定，为数千设备监听服务。

小乌鱼
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c#: 线程状态和管理之线程的休眠、挂起和中断
火焰
03-15 1万+
环境： window 10 .netcore 3.1.1 vs2019 16.4.5 一、线程的状态 线程的状态可以从枚举ThreadState中查看到： public enum ThreadState { Running = 0x0, StopRequested = 0x1, SuspendRequested = 0x2, Background = 0x4, ...
C# 线程控制
MintYouth的博客
10-18 681
首先.NET不太支持对线程的直接暂停，因为不安全。这个不安全体现在，你不知道线程正在运行到哪个函数的哪个节点。所以，一般情况下，是用别的方法来让线程停下的。这个停下，一般情况下就是干完一个您认为完整的业务。如果您硬要强制暂停，那就suspend方法，然后用resume方法重启，但这个方法相信你试过，并不好用。
C# 网络编程 线程管理
imxlw00的专栏
07-30 459
概念 一个进程可以划分为若干个独立的执行流，这些独立的执行流称为线程。 任何一个C#程序都有一个默认的线程，该线程称为主线程。主线程执行程序中Main方法中的代码。Main方法中的每一条语句都由主线程执行，当Main返回时，主线程也自动终止。 除了主线程外，还可以创建其他线程，其他的线程可以与主线程一起并行执行。主线程之外 的其他线程称为辅助线程。 Thread Thread类位于System.Threading命名空间下。 Thread类是用于创建和控制线程的,对线程的常用操作有：启动线程、终止线程、合并
C# 多线程的自动管理(线程池)
weixin_33698823的博客
04-01 325
在多线程的程序中，经常会出现两种情况：    1. 应用程序中线程把大部分的时间花费在等待状态，等待某个事件发生，然后给予响应。这一般使用 ThreadPool（线程池）来解决。     2. 线程平时都处于休眠状态，只是周期性地被唤醒。这一般使用 Timer（定时器）来解决。 ThreadPool 类提供一个由系统维护的线程池（可以看作一个线程的容器），该容器需要 Windows 2000 以...
C#多线程编程技术——多线程操作（没看懂）
DXB2021的博客
07-13 3135
多线程操作
C#实现多线程下载文件的方法
09-03
首先，我们需要创建一个类，例如名为`MultiDownload`，用于管理多线程下载的过程。这个类中会包含一些关键属性，如文件名、文件大小、文件URL、保存路径、线程数量等。这些属性可以帮助我们跟踪下载的状态。此外，还...
C#停止线程的方法
09-03
这通常通过使用`System.Threading.CancellationTokenSource`和`System.Threading.CancellationToken`类来实现。 在提供的代码示例中，可以看到以下关键知识点： 1. **CancellationTokenSource**：这个类用于创建一...
C#多线程多任务管理模型.zip
04-09
- **ThreadManager.cs**：可能包含线程管理类，用于创建、控制和协调线程。 - **FormMain.Designer.cs, FormMain.cs**：设计和实现主窗体，可能包含多线程交互的UI逻辑。 - **UtilHelper.cs**：工具类，可能包含...
C#线程管理类，使线程有序执行
07-28
首先，`System.Threading`命名空间提供了丰富的线程管理类。例如，`Thread`类用于创建和管理线程，而`Monitor`、`Mutex`、`Semaphore`、`EventWaitHandle`等类则提供了线程同步和互斥访问的手段。 1. **线程同步**...
C#实现线程安全的简易日志记录方法
09-04
总结来说，这个简易的日志记录方法在 C# 中通过线程安全的方式实现了日志的收集和持久化，支持不同的日志级别，能够适应多线程环境，且具有日志文件大小管理功能，适合在小型项目或工具中使用。然而，对于大型复杂...
C#线程详解,单线程，多线程,线程管理
07-22
C#线程详解,单线程，多线程,线程管理 C#线程详解,单线程，多线程,线程管理
csharp多线程示例(全)
04-19
csharp多线程示例(全)，根据网上教材重写的示例代码，纠正了教材上面的一些小Bug
C#中的线程(三)使用多线程
12-09
单元模式和Windows Forms BackgroundWorker类 ReaderWriterLock类 线程池 异步委托 计时器 局部储存
利用C#编写管理系统
weixin_45759781的博客
12-09 1840
namespace 工具箱测试 { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void Form1_Load(object sender, EventArgs...
【Java并发编程】Java多线程（五）：关于线程的几个问题
A minor
09-16 1611
1.子线程 1 去等待子线程 2 执行完成之后才能执行，如何去实现？ 答：这里考察的就是 Thread.join 方法，我们可以这么做： @Test public void testJoin2() throws Exception { // 线程2 Thread thread2 = new Thread(new Runnable() { public void run() {...} }); // 线程1 Thread thread1 = new Thread(new Runna
c#线程基础之线程控制
热门推荐
jinjazz
06-20 1万+
用ManualResetEvent和AutoResetEvent可以很好的控制线程的运行和线程之间的通信。msdn的参考为： http://msdn.microsoft.com/zh-cn/library/system.threading.autoresetevent.aspx http://msdn.microsoft.com/zh-cn/library/system.threading
C#学习之路--线程与委托
Three_ST的博客
07-10 2147
委托是一个类，它定义了方法的类型，使得可以将方法转换成另一个方法的参数类进行传递，这种将方法动态给参数赋值的方法。可以再程序中避免大量使用（IF-ELSE、SWITCH）,同时使得程序具有更好的扩展性。winform下例程：GreetingManager文件如下：using System; using System.Collections.Generic; using System.Linq; u...
C#线程安全对象池实现
最新发布
01-18
以下是一个C#线程安全对象池的实现示例： ```csharp using System; using System.Collections.Concurrent; public class ObjectPool<T> { private readonly Func<T> _objectFactory; private readonly ConcurrentBag<T> _objects; private readonly int _maxObjects; public ObjectPool(Func<T> objectFactory, int maxObjects) { _objectFactory = objectFactory; _objects = new ConcurrentBag<T>(); _maxObjects = maxObjects; } public T GetObject() { T obj; if (_objects.TryTake(out obj)) { return obj; } return _objectFactory(); } public void PutObject(T obj) { if (_objects.Count < _maxObjects) { _objects.Add(obj); } else { // 如果对象池已满，则不放回对象池，直接释放对象 // 或者可以选择其他处理方式，比如抛出异常 // 这里只是一个简单的示例 DisposeObject(obj); } } private void DisposeObject(T obj) { if (obj is IDisposable disposable) { disposable.Dispose(); } } } ``` 这个对象池类使用了`ConcurrentBag`来实现线程安全的对象管理。在创建`ObjectPool`对象时，需要传入一个用于创建对象的委托函数和一个最大对象数的限制。当需要获取对象时，先尝试从对象池中获取一个可用的对象，如果对象池中没有可用的对象，则根据委托函数创建一个新的对象。使用完毕后，将对象放回对象池中。如果对象池已满，则不放回对象池，直接释放对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小乌鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值