封装：Task任务管理

最新推荐文章于 2023-11-15 17:04:58 发布
最新推荐文章于 2023-11-15 17:04:58 发布
阅读量1.7k 收藏 5
点赞数
分类专栏： C# 文章标签： 扩展 应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010975589/article/details/52922112
版权

一、TaskL类型简介


二、目的：封装Task类、调用方便可控

三、实现过程

1、定义接口：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

namespace HebianGu.ComLibModule.TaskEx
{
    /// <summary> 执行任务类型的接口 </summary>
    public interface IWorkInterface
    {
        /// <summary> 工作函数 </summary>
        int RunWork(CancellationToken pToken);

    }

    /// <summary> 任务管理器 </summary>
    public interface ITaskList : IWorkInterface
    {
        /// <summary> 当前任务 </summary>
        Task<int> TaskCore
        {
            get;
            set;
        }

        /// <summary> 上级任务 </summary>
        Task<int> ParentTaskCore
        {
            get;
            set;
        }
        /// <summary> 全局任务控制 </summary>
        CancellationTokenSource Cts
        {
            get;
            set;
        }
    }

    /// <summary> 包含：开始时间，结束事件，用时，运行状态，暂停，文件路径，文件名等状态 </summary>
    public class BaseTaskCore : ITaskList
    {
        bool isPause;
        /// <summary> 是否暂停状态 </summary>
        public bool IsPause
        {
            get { return isPause; }
            set { isPause = value; }
        }
        bool isRestart = false;
        /// <summary> 暂停继续后是否重新计算 </summary>
        public bool IsRestart
        {
            get { return isRestart; }
            set { isRestart = value; }
        }


        /// <summary> 抽象方法，提供子类扩展 </summary>
        public virtual int RunCaseTaskWork(System.Threading.CancellationToken pToken)
        {
            //Process p = new Process();

            //p.RunExe("DemoConsoleExe.exe", "");

            return 0;
        }

        public int RunWork(System.Threading.CancellationToken pToken)
        {
            while (TaskControlModel.Instance.IsPause)
            {
                //  设置暂停状态
                if (!isPause)
                {
                    isPause = TaskControlModel.Instance.IsPause;
                }

            }

            startTime = DateTime.Now;

            isPause = TaskControlModel.Instance.IsPause;

            RunCaseTaskWork(pToken);


            //  如果是中间停止则重新计算
            while (TaskControlModel.Instance.IsPause)
            {
                Thread.Sleep(1000);
                //  设置暂停状态
                if (!IsPause)
                {
                    isPause = TaskControlModel.Instance.IsPause;

                }
            }

            IsPause = TaskControlModel.Instance.IsPause;

            if (isRestart)
            {
                isRestart = false;
                RunWork(pToken);
            }

            endTime = DateTime.Now;

            return 0;

        }

        DateTime startTime;

        public DateTime StartTime
        {
            get { return startTime; }
            set { startTime = value; }
        }

        DateTime endTime;

        public DateTime EndTime
        {
            get { return endTime; }
            set { endTime = value; }
        }

        /// <summary> 记录用时 </summary>
        public string Time
        {
            get
            {
                if (endTime == default(DateTime))
                {
                    if (startTime == default(DateTime))
                    {

                        string r = Regex.Replace(new TimeSpan().ToString(), @"\.\d+$", string.Empty);
                        TimeSpan ts = TimeSpan.Parse(r);
                        return ts.ToString();
                    }
                    else
                    {
                        string r = Regex.Replace((DateTime.Now - startTime).ToString(), @"\.\d+$", string.Empty);
                        TimeSpan ts = TimeSpan.Parse(r);
                        return ts.ToString();
                    }
                }
                else
                {
                    string r = Regex.Replace((endTime - startTime).ToString(), @"\.\d+$", string.Empty);
                    TimeSpan ts = TimeSpan.Parse(r);
                    return ts.ToString();
                }
            }
        }

        Task<int> task;

        public Task<int> TaskCore
        {
            get
            {
                return task;
            }
            set
            {
                task = value;
            }
        }

        Task<int> pTask;

        public Task<int> ParentTaskCore
        {
            get
            {
                return pTask;
            }
            set
            {
                pTask = value;
            }
        }

        public string Id
        {
            get
            {
                return task.Id.ToString();
            }
        }

        public string Pid
        {
            get
            {
                return pTask == null ? string.Empty : pTask.Id.ToString();
            }
        }


        public bool IsCanceled
        {
            get
            {
                return task.IsCanceled;
            }
        }
        public bool IsCompleted
        {
            get
            {
                return task.IsCompleted;
            }
        }
        public bool IsFaulted
        {
            get
            {
                return task.IsFaulted;
            }
        }

        public string Status
        {
            get
            {
                if (isPause)
                {
                    return "暂停";
                }
                switch (task.Status)
                {
                    case TaskStatus.Created:
                        return "准备";
                    case TaskStatus.WaitingForActivation:
                        return "等待";
                    case TaskStatus.WaitingToRun:
                        return "尚未开始执行";
                    case TaskStatus.Running:
                        return "运行";
                    case TaskStatus.WaitingForChildrenToComplete:
                        return "等待子任务";
                    case TaskStatus.RanToCompletion:
                        return "完成";
                    case TaskStatus.Canceled:
                        return "取消";
                    case TaskStatus.Faulted:
                        return "异常";
                    default:
                        return "";
                }
            }
        }

        CancellationTokenSource _cts;

        public CancellationTokenSource Cts
        {
            get
            {
                return _cts;
            }
            set
            {
                _cts = value;
            }
        }

    }



}

2、定义任务处理殷勤

注:BaseFactory<TaskListManager<T>>部分参考封装：实现单例、多例模式，业务层继承调用

using HebianGu.ComLibModule.Factory;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace HebianGu.ComLibModule.TaskEx
{
    /// <summary> 这是一个连续的任务，依次执行各个任务 </summary>
    public class TaskListManager<T> : BaseFactory<TaskListManager<T>> where T : ITaskList
    {

        #region - Start 内部成员-

        //  取消控制
        CancellationTokenSource cts = null;

        /// <summary> 是否已被取消 </summary>
        public bool IsCancel
        {
            get
            {
                return cts.IsCancellationRequested;
            }
        }


        LinkedList<T> taskList = null;

        /// <summary> 任务的双向链表 </summary>
        public LinkedList<T> TaskList
        {
            get { return taskList; }
            set { taskList = value; }
        }

        /// <summary> 线程互斥 </summary>
        private static object m_obj = new object();

        T runTask;
        /// <summary> 用于记录当前正在执行的任务 </summary>
        public T RunTask
        {
            get { return runTask; }
            set { runTask = value; }
        }

        /// <summary> 当切换进程时外部调用 </summary>
        Action<Task<int>, T> _act;

        /// <summary> 当切换进程时外部调用 </summary>
        Func<Task<int>, int> _allOver;

        /// <summary> 任务总数 </summary>
        public int TotalCount
        {
            get { return this.taskList.Count; }
        }

        /// <summary> 完成的任务 </summary>
        public List<T> CompleteTask
        {
            get { return this.taskList.ToList().FindAll(l => l.TaskCore.IsCompleted); }
        }

        /// <summary> 取消的任务</summary>
        public List<T> CancelTask
        {
            get { return this.taskList.ToList().FindAll(l => l.TaskCore.IsCanceled); }
        }

        /// <summary> 异常的任务 </summary>
        public List<T> FaultTask
        {
            get { return this.taskList.ToList().FindAll(l => l.TaskCore.IsFaulted); }
        }

        /// <summary> 是否全部运行完 </summary>
        public bool IsComplete
        {
            get { return (CompleteTask.Count + CancelTask.Count + FaultTask.Count) == TotalCount; }

        }

        /// <summary> act:上一任务完成下一任务开始要处理的方法 </summary>
        public TaskListManager(Action<Task<int>, T> act)
        {
            _act = act;

            if (taskList == null)
                taskList = new LinkedList<T>();

            if (cts == null)
                cts = new CancellationTokenSource();

        }

        public TaskListManager()
        {

            if (taskList == null)
                taskList = new LinkedList<T>();

            if (cts == null)
                cts = new CancellationTokenSource();

        }

        /// <summary> act:上一任务完成下一任务开始要处理的方法 allOver所有任务都处理完的处理的方法  </summary>
        public TaskListManager(Action<Task<int>, T> act, Func<Task<int>, int> allOver)
        {
            _act = act;

            _allOver = allOver;

            if (taskList == null)
                taskList = new LinkedList<T>();

            if (cts == null)
                cts = new CancellationTokenSource();

        }



        /// <summary> 运行结束 p1 = 上一任务 p2 = 调用的接口 r = 任务的结果</summary>
        int ContinueWith(Task<int> pTask, T worker)
        {
            //  设置取消参数
            if (cts.IsCancellationRequested)
            {
                return TaskResultID.CacelParam;
            }

            //  正在执行任务
            //runTask = taskList.First(l => l.TaskCore.Id == pTask.Id);
            runTask = worker;

            //  触发任务交接
            if (_act != null)
                _act(pTask, runTask);


            int result = worker.RunWork(cts.Token);

            return result;

        }

        int TaskStartTask(T worker)
        {
            return worker.RunWork(cts.Token);
        }

        #endregion - 内部成员 End -E

        /// <summary> 在末尾创建任务 p1=当前任务对应的接口  p2 = 是否自动运行</summary>
        public void ContinueLast(T worker, bool autoRun=false)
        {
            //  不存在新增
            if (taskList.Count == 0)
            {
                //  创建进程
                Task<int> firstTask = new Task<int>(l => TaskStartTask(worker), cts.Token);
                worker.TaskCore = firstTask;
                runTask = worker;
                taskList.AddFirst(worker);
                return;
            }

            //  获取最后节点
            T lastTask = taskList.Last.Value;

            //  设置报错取消
            lastTask.TaskCore.ContinueWith<int>(
                l =>
                {
                    cts.Cancel();
                    return TaskResultID.FaultParam;
                },
                TaskContinuationOptions.OnlyOnFaulted
                );

            //  增加当前任务
            Task<int> addTask = lastTask.TaskCore.ContinueWith<int>
                (
                l => ContinueWith(l, worker),
                cts.Token,
                TaskContinuationOptions.None,
                TaskScheduler.Default
                );

            worker.TaskCore = addTask;

            worker.ParentTaskCore = lastTask.TaskCore;

            taskList.AddLast(worker);


            if (autoRun && this.IsCancel)
            {
                this.Start();
            }

        }

        /// <summary> 执行任务 </summary>
        public void Start()
        {
            //  触发完成事件
            if (_allOver != null)
                taskList.Last.Value.TaskCore.ContinueWith<int>(_allOver, cts.Token);

            cts = new CancellationTokenSource();

            if (taskList.First.Value.TaskCore.Status == TaskStatus.Created)
            {
                taskList.First.Value.TaskCore.Start();
            }

            //var find = FindNextWaitRun(taskList.First.Value);

            //if (find != null)
            //{
            //    find.TaskCore.Start();
            //}


        }
        /// <summary> 查找最新可执行任务 </summary>
        T FindNextWaitRun(T task)
        {
            var pTask = taskList.Find(task);

            if (pTask != null)
            {
                if (pTask.Value.TaskCore.Status == TaskStatus.WaitingForActivation || pTask.Value.TaskCore.Status == TaskStatus.Created)
                {
                    return pTask.Value;
                }
                else
                {
                    if (pTask.Next != null)
                    {
                        return FindNextWaitRun(pTask.Next.Value);
                    }
                    else
                    {
                        return default(T);
                    }
                }
            }
            else
            {
                return default(T);
            }

        }

        /// <summary> 等待所有任务结束 p1 = 单位秒 超时限制</summary>
        public void Wait(int millisecondsTimeout = 0)
        {
            if (millisecondsTimeout == 0)
            {
                Task.WaitAll(taskList.Select(l => l.TaskCore).ToArray());
            }
            else
            {
                Task.WaitAll(taskList.Select(l => l.TaskCore).ToArray(), millisecondsTimeout);
            }

        }

        /// <summary> 停止所有任务 </summary>
        public T Stop()
        {
            //  调用取消
            cts.Cancel();

            return this.runTask;

        }

        /// <summary> 暂停 </summary>
        public T Pause()
        {
            TaskControlModel.Instance.IsPause = true;
            return this.runTask;

        }

        /// <summary> 继续 </summary>
        public void Continue()
        {
            cts = new CancellationTokenSource();

            TaskControlModel.Instance.IsPause = false;
        }

        /// <summary> 清理任务 </summary>
        public void ClearTask()
        {
            taskList.Clear();

            cts = new CancellationTokenSource();
        }

    }

    /// <summary> 控制参数 </summary>
    public class TaskControlModel : BaseFactory<TaskControlModel>
    {
        bool isPause = false;

        public bool IsPause
        {
            get { return isPause; }
            set { isPause = value; }
        }
    }
}
3、定义任务执行状态 

    /// <summary> 任务的执行结果 </summary>
    public class TaskResultID
    {
        /// <summary> 运行结束 </summary>
        public static int CompleteParam { get { return -9999999; } }

        /// <summary> 运行取消 </summary>
        public static int CacelParam { get { return -8888888; } }

        /// <summary> 运行报错 </summary>
        public static int FaultParam { get { return -7777777; } }
    }


四、示例 

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace HebianGu.ComLibModule.TaskEx
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
            for (int i = 0; i < 5; i++)
            {
                //  创建记事本任务
                CaseTaskCore caseTaskCore = new CaseTaskCore();
                caseTaskCore.FilePath = "notepad";
                caseTaskCore.FileName = "notepad";

                //  将记事本添加到任务管理器中
                TaskListManager<CaseTaskCore>.Instance.ContinueLast(caseTaskCore, true);

            }
        }
    }

    public class CaseTaskCore : BaseTaskCore
    {
        string fileName;
        /// <summary> 文件名称 </summary>
        public string FileName
        {
            get { return fileName; }
            set { fileName = value; }
        }

        string filePath;
        /// <summary> 文件全路径 包含文件名 </summary>
        public string FilePath
        {
            get { return filePath; }
            set { filePath = value; }
        }

        Process p;
        public override int RunCaseTaskWork(System.Threading.CancellationToken pToken)
        {
            Console.WriteLine("开始执行任务：" + this.GetType().Name);

            //  启动进程
            p = Process.Start(this.filePath);

            return 0;
        }

        /// <summary> 停止任务 </summary>
        public void Stop()
        {
            this.IsRestart = false;

            if (p.HasExited)
                return;

            this.p.CloseMainWindow();

            p.Kill();
        }
    }
}


He BianGu
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#任务之Task
jmelzc的博客
06-12 618
C#任务之Task背景任务的开启思考总结 背景 今天在疯狂输出代码的时候，利用Parallel.Foreach()来编写并行程序的时候出现问题了，然后Parallel是基于Task的，所以我决定，先研究一下Task。 文章后续主要是模拟一位大厨准备早餐，包括煎蛋和煮咖啡两件事。煎蛋和煮咖啡两件事情是可以异步进行的，比如，可以先开始煮咖啡，在等待过程中（比如烧水耗时长，只需等待不需操作），就可以先开始着煎蛋的，然后两件事情交互着进行。 任务的开启 我们先来定义一下煮咖啡和煎鸡蛋两个方法 sta
tgtools.core:通用工具封装
04-22
tgtools.core通用工具封装常用功能：数据源管理（db）后台服务管理（service 简单调度任务实现）插件管理(plugin)简单消息管理(message)常用工具（util）缓存（ehcache)任务模型（task）网络交互对象（net）关键版本...
task任务管理系统源码
02-05
任务管理系统源码 一个采用VS2008+Sql2000开发的任务管理系统有任务管理和角色管理等
AsyncTask使用详解
Mr.li 的博客∮
08-11 602
一、基础篇 1）UI线程概念          Android为单线程模型。当一个程序第一次启动时，Android会自动创建一个对应的主线程（Main Thread）。它负责把事件分派到相应的控件，用于用户与Android控件进行交互。所以通常又被叫做UI线程。          在开发Android应用时必须遵守单线程模型的原则：Android UI操作并不是线程安全的并且这些操作
互斥量与事件标志组
最新发布
GoodtimeGood的博客
11-15 183
优先级继承：当一个互斥信号量正在被一个低优先级的任务持有时， 如果此时有个高优先级的任。在多数情况下，互斥型信号量和二值型信号量非常相似，但是从功能上二值型信号量用于同步，优先级继承并不能完全的消除优先级翻转的问题，它只是尽可能的降低优先级翻转带来的影响。互斥型信号量和二值型信号量还有一个最大的区别，互斥型信号量可以有效解决优先级反转现。务也尝试获取这个互斥信号量，那么这个高优先级的任务就会被阻塞。释放信号量的过程中，中等优先级任务M。，从而延迟了信号量的释放时间，导致。占有资源，锁定了信号量，
.NET 同步与异步之封装成Task（五）
weixin_34310127的博客
12-13 384
本随笔续接：.NET 实现并行的几种方式（四）   前篇随笔已经介绍了几种可以实现并发的方式，其中异步方法、是最简便的方式。而 异步方式是基于 Task 和 async修饰符和await运算符实现的。 换句话说：如果我们有了Task、就有了异步方法。 在随笔：.NET 实现并行的几种方式（二） 中，已经简单的介绍了 Task.Run(); 利用Task.Run();我们可以很轻松的将同步代...
C#编程：Task的使用
博客常用背景
03-11 782
持续功能，C#学习总结汇总线程部分Task的使用Task的说明Task的简单使用Task的超时检测Task的带参数及返回值使用带返回值带一个参数和返回值多个使用和返回值 线程部分 Task的使用 Task的说明 暂时只知道这玩意是实现异步多线程的使用法宝 Task的简单使用 //单个使用 Task.Run(()=> { //丢到后台运行的耗时业务逻辑代码 }); .
C#中关于Task（任务）的简单介绍
qq_43565708的博客
04-19 1838
FCL提供了Task类型，提供了更加丰富计算限制的异步操作，全部是在线程池中创建的线程。
Task的用法学习（一）
yw1688的专栏
07-20 2540
using System; using System.Collections.Generic; using System.Threading.Tasks; using System.Threading; namespace TaskTest2 { class Program { static void Main(string[] args) {
破晓：Dawn是用于前端和nodejs的轻量级任务管理和构建工具
02-04
黎明轻量级的任务管理和构建工具。npm i -gDawn取“黎明，破晓”之意，原为“阿里云·业务运营团队”内部的前端集成和工程化工具，完全完全开放。它通过pipeline和middleware将开发过程抽象为相对固定的阶段和有限的...
Narrange是一个.NET代码管理工具
08-11
Narrange是一个.NET代码管理工具。它可以对源代码自动进行美化和把类成员分成一个组、区域。目前支持C#、VB.NET，将来会支持更多.NET上的语言。 主要的作用是： ◆ 减少程序员的开发时间 ◆ 使得编码风格变得标准 ◆ 能减少代码冲突 ◆ 能代码进行分组 ◆ 很好的灵活性
WPFc#开源控件库HandyControl-master.rar
02-03
WPFc#开源控件库HandyControl-master.rar
TaskManager:负责不同后台任务的经理
04-01
任务管理器 Task Manager是一个Swift库，用于在iOS开发过程中管理各种后台任务。 它实现了高级队列逻辑，该逻辑考虑了操作的优先级，从而可以更高效地开发iOS应用。 介绍 任务管理器是应用程序核心的一个元素，借助...
vue-concurrency:一个用于封装异步操作并管理Vue和Composition API并发性的库
04-13
isRunning, isIdle, isFinished, isCancelled等并发管理： drop() ， restartable() ， enqueue()和其他任务SSR支持（实验性）安装 :package:演示版 :magnifying_glass_tilted_left: :vertical_traffic_light:
celery.node:Node.js的Celery任务队列客户端工作器
04-29
代理（任务队列）从“生产者”接收封装为消息的任务，并将其路由到“消费者”。 但是，管理消息并不像将消息存储在数据队列中那样简单。 假设大量生产者和工人发送和发送了许多消息。 我们必须在下面考虑。 检测...
整理：C#中Expression表达式的妙用
热门推荐
HeBianGu的博客
12-30 4万+
一、目的：通过示例了解C#中Expression表达式的作用，通过表达式和反射可以写出很优雅的代码和架构，也可以完成一些看似不可能完成的任务   二、示例： 1、通过表达式获取成员属性 定义模型： [Description("唯一标识")] class PersonModel { [Description("唯一标识")] pub...
示例：WPF开发的可视化大屏示例
HeBianGu的博客
01-08 1万+
一、目的：利用PhotoShop分解PSD可视化文件，获取图片等背景资源放入WPF中构建自己的可视化大屏项目   二、效果图(半成品，后续更新..)   原psd效果图   三、参考代码（本示例仅供学习交流） GitHub - https://github.com/HeBianGu/WPF-ScreenData.git...
封装：WPF绘制曲线视图
HeBianGu的博客
05-09 1万+
一、目的：绘制简单轻量级的曲线视图 二、实现： 1、动画加载曲线 2、点击图例显示隐藏对应曲线 3、绘制标准基准线 4、绘制蒙板显示标准区域 曲线图示例： 心电图示例： 三、实现代码 View： &lt;echart:StaticCurveChartPlotter x:Name="chart" Background="White" DataSource="{Bi...
整理：WPF中CommandBindings的用法
HeBianGu的博客
10-20 1万+
目的：了解一下CommandBindings、InputBindings、ICommandSource中在WPF中扮演什么样的角色   CommandBindings： 将应用程序要执行的功能封装到中间层组件或独立的类中：可以将所有命令统一封装，统一管理，统一调用 定义过程： //将所有命令封装在一个类里面 public class MyCommands { ...
Android任务管理器
09-16
Android任务管理器是一个用于管理和监控应用程序中的任务和进程的工具。它可以帮助用户查看和关闭正在运行的应用程序和服务，以释放内存和提高设备性能。 在提供的代码片段中，有两个方法doTimeoutTask和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值