winform开发使用通用多线程基类分享(以队列形式)

代码如下:

/// <summary>
    /// 队列多线程,T 代表处理的单个类型~
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class QueueThreadBase<T>
    {
        #region 变量&属性
        /// <summary>
        /// 待处理结果
        /// </summary>
        private class PendingResult
        {
            /// <summary>
            /// 待处理值
            /// </summary>
            public T PendingValue { get; set; }
            /// <summary>
            /// 是否有值
            /// </summary>
            public bool IsHad { get; set; }
        }
        /// <summary>
        /// 线程数
        /// </summary>
        public int ThreadCount
        {
            get { return this.m_ThreadCount; }
            set { this.m_ThreadCount = value; }
        }
        private int m_ThreadCount = 5;
        /// <summary>
        /// 取消=True
        /// </summary>
        public bool Cancel { get; set; }
        /// <summary>
        /// 线程列表
        /// </summary>
        List<Thread> m_ThreadList;
        /// <summary>
        /// 完成队列个数
        /// </summary>
        private volatile int m_CompletedCount = 0;
        /// <summary>
        /// 队列总数
        /// </summary>
        private int m_QueueCount = 0;
        /// <summary>
        /// 全部完成锁
        /// </summary>
        private object m_AllCompletedLock = new object();
        /// <summary>
        /// 完成的线程数
        /// </summary>
        private int m_CompetedCount = 0;
        /// <summary>
        /// 队列锁
        /// </summary>
        private object m_PendingQueueLock = new object();
        private Queue<T> m_InnerQueue;
        #endregion

#region 事件相关
        /// <summary>
        /// 全部完成事件
        /// </summary>
        public event Action<CompetedEventArgs> AllCompleted;
        /// <summary>
        /// 单个完成事件
        /// </summary>
        public event Action<T, CompetedEventArgs> OneCompleted;
        /// <summary>
        /// 引发全部完成事件
        /// </summary>
        /// <param name="args"></param>
        private void OnAllCompleted(CompetedEventArgs args)
        {
            if (AllCompleted != null)
            {
                try
                {
                    AllCompleted(args);//全部完成事件
                }
                catch { }
            }
        }
        /// <summary>
        /// 引发单个完成事件
        /// </summary>
        /// <param name="pendingValue"></param>
        /// <param name="args"></param>
        private void OnOneCompleted(T pendingValue, CompetedEventArgs args)
        {
            if (OneCompleted != null)
            {
                try
                {
                    OneCompleted(pendingValue, args);
                }
                catch { }

}
        }
        #endregion

#region 构造
        public QueueThreadBase(IEnumerable<T> collection)
        {
            m_InnerQueue = new Queue<T>(collection);
            this.m_QueueCount = m_InnerQueue.Count;
        }

#endregion

#region 主体
        /// <summary>
        /// 初始化线程
        /// </summary>
        private void InitThread()
        {
            m_ThreadList = new List<Thread>();
            for (int i = 0; i < ThreadCount; i++)
            {
                Thread t = new Thread(new ThreadStart(InnerDoWork));
        m_ThreadList.Add(t);
                t.IsBackground = true;
                t.Start();
            }
        }
        /// <summary>
        /// 开始
        /// </summary>
        public void Start()
        {
            InitThread();
        }
        /// <summary>
        /// 线程工作
        /// </summary>
        private void InnerDoWork()
        {
            try
            {
                Exception doWorkEx = null;
                DoWorkResult doworkResult = DoWorkResult.ContinueThread;
                var t = CurrentPendingQueue;
                while (!this.Cancel && t.IsHad)
                {
                    try
                    {
                        doworkResult = DoWork(t.PendingValue);
                    }
                    catch (Exception ex)
                    {
                        doWorkEx = ex;
                    }
                    m_CompletedCount++;
                    int precent = m_CompletedCount * 100 / m_QueueCount;
                    OnOneCompleted(t.PendingValue, new CompetedEventArgs() { CompetedPrecent = precent, InnerException = doWorkEx });
                    if (doworkResult == DoWorkResult.AbortAllThread)
                    {
                        this.Cancel = true;
                        break;
                    }
                    else if (doworkResult == DoWorkResult.AbortCurrentThread)
                    {
                        break;
                    }
                    t = CurrentPendingQueue;
                }

lock (m_AllCompletedLock)
                {
                    m_CompetedCount++;
                    if (m_CompetedCount == m_ThreadList.Count)
                    {
                        OnAllCompleted(new CompetedEventArgs() { CompetedPrecent = 100 });
                    }
                }

}
            catch
            {
                throw;
            }
        }
        /// <summary>
        /// 子类重写
        /// </summary>
        /// <param name="pendingValue"></param>
        /// <returns></returns>
        protected virtual DoWorkResult DoWork(T pendingValue)
        {
            return DoWorkResult.ContinueThread;
        }
        /// <summary>
        /// 获取当前结果
        /// </summary>
        private PendingResult CurrentPendingQueue
        {
            get
            {
                lock (m_PendingQueueLock)
                {
                    PendingResult t = new PendingResult();
                    if (m_InnerQueue.Count != 0)
                    {
                        t.PendingValue = m_InnerQueue.Dequeue();
                        t.IsHad = true;
                    }
                    else
                    {
                        t.PendingValue = default(T);
                        t.IsHad = false;
                    }
                    return t;
                }
            }
        }

#endregion

#region 相关类&枚举
        /// <summary>
        /// dowork结果枚举
        /// </summary>
        public enum DoWorkResult
        {
            /// <summary>
            /// 继续运行,默认
            /// </summary>
            ContinueThread = 0,
            /// <summary>
            /// 终止当前线程
            /// </summary>
            AbortCurrentThread = 1,
            /// <summary>
            /// 终止全部线程
            /// </summary>
            AbortAllThread = 2
        }
        /// <summary>
        /// 完成事件数据
        /// </summary>
        public class CompetedEventArgs : EventArgs
        {
            public CompetedEventArgs()
            {

}
            /// <summary>
            /// 完成百分率
            /// </summary>
            public int CompetedPrecent { get; set; }
            /// <summary>
            /// 异常信息
            /// </summary>
            public Exception InnerException { get; set; }
        }
        #endregion

}

1.从构造函数来看,处理的是一个确定的列表.没错.这个多线程只能处理已经确定的列表,你是否会问.可不可以一边添加,一边处理呢?(呵呵,可以,请联系楼主,当然你也可以自己写,是吧?!)

代码如下:

public QueueThreadBase(IEnumerable<T> collection)

2.提供撤销的功能

代码如下:

/// <summary>
        /// 取消=True
        /// </summary>
        public bool Cancel { get; set; }

3.提供线程个数修改功能

代码如下:

/// <summary>
        /// 线程数
        /// </summary>
        public int ThreadCount
        {
            get { return this.m_ThreadCount; }
            set { this.m_ThreadCount = value; }
        }

4.提供多种事件响应,如单个完成,全部完成的事件

代码如下:

/// <summary>
        /// 全部完成事件
        /// </summary>
        public event Action<CompetedEventArgs> AllCompleted;
        /// <summary>
        /// 单个完成事件
        /// </summary>
        public event Action<T, CompetedEventArgs> OneCompleted;

5.提供完成的百分率

代码如下:

/// <summary>
        /// 完成事件数据
        /// </summary>
        public class CompetedEventArgs : EventArgs
        {
            public CompetedEventArgs()
            {

}
            /// <summary>
            /// 完成百分率
            /// </summary>
            public int CompetedPrecent { get; set; }
            /// <summary>
            /// 异常信息
            /// </summary>
            public Exception InnerException { get; set; }
        }

6.提供终止线程的方式,继续/单线程终止/全部终止

代码如下:

/// <summary>
        /// dowork结果枚举
        /// </summary>
        public enum DoWorkResult
        {
            /// <summary>
            /// 继续运行,默认
            /// </summary>
            ContinueThread = 0,
            /// <summary>
            /// 终止当前线程
            /// </summary>
            AbortCurrentThread = 1,
            /// <summary>
            /// 终止全部线程
            /// </summary>
            AbortAllThread = 2
        }

你是否会问?怎么用呢?别急....请看

代码如下:

/// <summary>
    /// 下载线程对了.
    /// </summary>
    public class DownLoadQueueThread:QueueThreadBase<int>
    {
        /// <summary>
        ///
        /// </summary>
        /// <param name="list">下载的列表ID</param>
        public DownLoadQueueThread(IEnumerable<int> list):base(list)
        {

}
        /// <summary>
        /// 每次多线程都到这里来,处理多线程
        /// </summary>
        /// <param name="pendingValue"列表ID></param>
        /// <returns></returns>
        protected override DoWorkResult DoWork(int pendingID)
        {
            try
            {

//..........多线程处理....
                return DoWorkResult.ContinueThread;//没有异常让线程继续跑..

}
            catch (Exception)
            {

return DoWorkResult.AbortCurrentThread;//有异常,可以终止当前线程.当然.也可以继续,
                //return  DoWorkResult.AbortAllThread; //特殊情况下 ,有异常终止所有的线程...
            }

//return base.DoWork(pendingValue);
        }
    }

用法

总结:

多线程在什么时候都会用到.不用到是你不会用.多线程要一定的编程基础,如果你觉得有点难度,那你可以学习并且借鉴人家已有的东西.少走弯路,是我们程序员经历嗷嗷待哺后的心声.本文以交流态度和感恩心态,贡献给有需要的人们.

(0)

相关推荐

  • c#中多线程访问winform控件的若干问题小结

    我们在做winform应用的时候,大部分情况下都会碰到使用多线程控制界面上控件信息的问题.然而我们并不能用传统方法来解决这个问题,下面我将详细的介绍. 首先来看传统方法: 复制代码 代码如下: public partial class Form1 : Form     {        public Form1()        {            InitializeComponent();        } private void Form1_Load(object sender,

  • c# winform多线程的小例子

    在文本框中输入一个数字,点击开始累加按钮,程序计算从1开始累计到该数字的结果.因为该累加过程比较耗时,如果直接在UI线程中进行,那么当前窗口将出现假死.为了有更好的用户体验,程序启动一个新的线程来单独执行该计算,然后每隔200毫秒读取一次累加结果,并把结果显示到文本框下方的label控件中.同时,程序支持取消操作,点击取消累计按钮,程序将取消累加操作,并把当前累加值显示到label中.为了方便后面的描述,我把UI线程称作主线程,把执行累加计算的线程称作工作者线程.该过程有两个关键点: 1:如何在

  • winform基于异步委托实现多线程摇奖器

    本文实例讲述了winform基于异步委托实现多线程摇奖器.分享给大家供大家参考.具体实现方法如下: 复制代码 代码如下: 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 Sys

  • 深入浅析WinForm 进程、线程及区别介绍

    一.进程 进程是一个具有独立功能的程序关于某个数据集合的一次运行活动. 它可以申请和拥有系统资源,是一个动态的概念,是一个活动的实体. Process 类,用来操作进程. 命名空间:using System.Diagnostics; Process.Start("calc"); //打开计算器 Process.Start("mspaint"); //打开画图 Process.Start("iexplore" , "http://www.

  • WinForm实现跨进程通信的方法

    本文实例展示了WinForm实现跨进程通信的方法,分享给大家供大家参考之用.具体方法如下: 主要功能代码如下: public class WinMessageHelper { private struct COPYDATASTRUCT { public IntPtr dwData; public int cbData; [MarshalAs(UnmanagedType.LPStr)] public string lpData; } //使用COPYDATA进行跨进程通信 public const

  • c# winform 关闭窗体时同时结束线程实现思路

    前不久,做一个winform小程序,是给客户导数据用的.当时就发现调试的时候,线程有点问题,到某个点时就走不动了.但是运行确实没有问题的. 只是在关闭窗体后,资源管理器里,一大堆进程. 当时,客户急着用,小测了下,导出数据无误,进程就先不管了. 后来自己去查资料,发现只要在线程那里设置个属性 复制代码 代码如下: Thread th = new Thread(Excute); th.IsBackground = true;这样就解决问题了. 这个属性的意思就是把线程设置为后台线程. 然后关闭进程

  • Winform基于多线程实现每隔1分钟执行一段代码

    本文实例讲述了Winform基于多线程实现每隔1分钟执行一段代码的方法,分享给大家供大家参考.具体实现方法如下: 1.定义相关的类Timer.cs,代码如下: 复制代码 代码如下: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; namespace SMIS2013.DSS.Monitor {     public class

  • winform开发使用通用多线程基类分享(以队列形式)

    复制代码 代码如下: /// <summary>    /// 队列多线程,T 代表处理的单个类型~    /// </summary>    /// <typeparam name="T"></typeparam>    public abstract class QueueThreadBase<T>    {        #region 变量&属性        /// <summary>      

  • Asp.Net 通用数据操作类 (附通用数据基类)第1/2页

    文章内容为本站编辑,创作.你可以任意转载.发布.使用但请务必以明文标注文章原始出处及本声明 http://www.opent.cn  作者:浪淘沙此贴的方法会持续更新, 此文件要引用与数据操作的基类 using System; using System.Data; using System.Configuration; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.Web

  • Asp.Net 数据操作类(附通用数据基类)

    using System; using System.Data; using System.Configuration; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.WebControls; using System.Web.UI.WebControls.WebParts; using System.Web.UI.HtmlControls; namespace EC {

  • C#通用邮件发送类分享

    此类的功能包括发送邮件,邮箱格式是否正确,和在不发送邮件的情况下判断邮箱用户名和密码是否正确,鉴于POP检查邮箱用户名和密码出现错误情况返回结果的延迟,用异步线程解决此问题,见代码: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net.Mail; using System.Web; using System.Net; using System.

  • php的memcache类分享(memcache队列)

    memcacheQueue.class.php 复制代码 代码如下: <?php/** * PHP memcache 队列类 * @author LKK/lianq.net * @version 0.3 * @修改说明: * 1.放弃了之前的AB面轮值思路,使用类似数组的构造,重写了此类. * 2.队列默认先进先出,但增加了反向读取功能. * 3.感谢网友FoxHunter提出的宝贵意见. * @example: * $obj = new memcacheQueue('duilie'); * $

  • 一个方便AJAX开发的通用类

    Name: AJAXRequest Author: HotHeart(xujiwei) Site: http://www.xujiwei.cn/ Blog: http://www.xujiwei.cn/blog/ Copyright (c) 2006, All Rights Reserved 类名:AJAXRequest 版本:0.3 日期:2006-12-18 介绍:AJAXRequest是一个方便AJAX开发的通用类,可以方便地进行一些AJAX中需要的操作,从而简化开发步骤,减少重复代码编写

  • 一个通用的Java分页基类代码详解

    分页的基类 import java.util.List; /** * 分页显示的标准类,基本操作,是先给予-当前页数一共的数据条数-每页显示的条数, * 然后在初始化该类,得到总共页数,和开始序号和结束序号, * 然后数据库分页用到开始序号和结束序号,得到数据集合后赋值给该类的list属性, * * 然后把该类发送到jsp页面,进行访问 * @author admin * * @param <T> */ public class PageBean<T> { private int

  • .Net Winform开发笔记(四)透过现象看本质

    写在前面: 从一个窗体的创建显示,再到与用户的交互,最后窗体关闭,这中间经历过了一系列复杂的过程,本文将从Winform应用程序中的Program.cs文件的第一行代码开始,逐步分析一个Winform应用程序到底是怎样从出生走向死亡,这其中包括Form.Show()和Form.ShowDialog()的区别.模式对话框形成的本质原因.消息循环.Windows事件与.net中事件(Event)的区别.System.Windows.Form.Application类的作用.以及我之前一篇博客中(.N

  • python 接口_从协议到抽象基类详解

    抽象基类的常见用途:实现接口时作为超类使用.然后,说明抽象基类如何检查具体子类是否符合接口定义,以及如何使用注册机制声明一个类实现了某个接口,而不进行子类化操作.最后,说明如何让抽象基类自动"识别"任何符合接口的类--不进行子类化或注册. Python文化中的接口和协议 接口在动态类型语言中是怎么运作的呢?首先,基本的事实是,Python语言没有 interface 关键字,而且除了抽象基类,每个类都有接口:类实现或继承的公开属性(方法或数据属性),包括特殊方法,如__getitem_

  • .Net WInform开发笔记(三)谈谈自制控件(自定义控件)

    末日这天写篇博客吧,既然没来,那就纪念一下. 这次谈谈自制控件,也就是自定义控件,先上图,再说 1.扩展OpenFileDialog,在OpenFileDialog中添加各种文件(.txt,.jpg,.excel等等)的预览功能 2.重写ListBox,增加折叠.鼠标背影.分类等功能 -----------------------------分割线--------------------------------------------------------------一.扩展OpenFileD

随机推荐