c#事件学习

本文,是自己在日常中用到的事件,然后自己总结的,没有查看相关文件,如果有高手能够看到本问,还希望能够指点下.谢谢

2008年1月7日

项目介绍:
联通hlr数据清理
本系统,由于现阶段有三个厂家的hlr需要清理,同时,由于联通的设备只支持单通道,因此,每个厂家只能支持一条条数据的做，不能够支持多条同时做,但是,各厂家之间是并行的,同时,由于西门子设备做一个查询后,需要停一下,释放一些东西,因此,做同样的数据两的清理,西门子做的时间明显大于其他厂家.

以前公司同事,采用的是每一个厂家,新开一个进程,每次执行500个号码,同时,这样有可能会使得其他设备的本次清理完成后，还在等待西门子设备清理,并且,如果有一个设备清理的过程中，出现错误,那么整个程序就死掉了.

2007年1月7日,该项目运行一段时间后,领导需要解决这个问题,因此,本人从公司调到联通,帮忙解决这个问题,查看系统流程后,打算改用事件,异步,回调等来做.
当天,自己给出了一个大概的模型,研究了下这个方式的可行性.
代码介绍如下:

HlrTaskTest
using System;

namespace HlrTaskTest
{
    /**//// <summary>
    /// ITask 的摘要说明。
    /// </summary>
    public interface ITask
    {
        string TaskName
        {
            get;
            set;
        }
        /**//// <summary>
        /// 任务执行状态
        /// </summary>
        TaskState TaskState
        {
            get;
            set;
        }

        /**//// <summary>
        /// 任务开始事件
        /// </summary>
        event TaskEventHandle BeginTask;
        
        /**//// <summary>
        /// 任务结束事件
        /// </summary>
        event TaskEventHandle TaskStoped;


    }

    /**//// <summary>
    /// 任务现在的运行状态
    /// </summary>
    public enum TaskState
    {
        /**//// <summary> 
        /// 任务已经结束
        /// </summary> 
        Stopped,  
        /**//// <summary>
        /// 开始任务
        /// </summary>
        Run,  
         
    }


    public class TaskEventArgs:EventArgs
    {

        private TaskState mTaskState;
        public TaskEventArgs(TaskState taskState)
        {
            this.mTaskState=taskState;
        }
        public TaskState TaskState
        {
            get
            {
                return this.mTaskState;
            }
        }
    }


    public delegate void  TaskEventHandle(object o,TaskEventArgs e);
}

HlrTaskTest
using System;

namespace HlrTaskTest
{
    /**//// <summary>
    /// Task 的摘要说明。
    /// </summary>
    public class Task:ITask    
    {
        public Task()
        {
             
        }
        private string mTaskName;
        public string TaskName
        {
            get
            {
                return mTaskName;
            }
            set
            {
                mTaskName=value;
            }
        }

        private TaskState mTaskState;
        /**//// <summary>
        /// 任务执行状态
        /// </summary>
        public TaskState TaskState
        {
            get
            {
                return this.mTaskState;
            }
            set
            {
                if(this.mTaskState!=value)
                {
                    mTaskState=value;
                
                    switch(mTaskState)
                    {
                        case TaskState.Run:
                            OnBeginTask();
                            break;
                        case TaskState.Stopped:
                            OnTaskStoped();
                            break;
                    }
                }
            }
        }
        /**//// <summary>
        /// 任务开始事件
        /// </summary>
        public event HlrTaskTest.TaskEventHandle BeginTask;
        
        protected void OnBeginTask()
        {
            if(this.BeginTask!=null)
            {
                BeginTask.BeginInvoke(this,new TaskEventArgs(TaskState.Run),
                    new AsyncCallback(TaskRunToEnd),null);
                //    BeginTask(this,new TaskEventArgs(TaskState.Run));
            }
        }

        private  void TaskRunToEnd(IAsyncResult ar)
        {
            this.TaskState=TaskState.Stopped;
        }
        /**//// <summary>
        /// 任务结束事件
        /// </summary>
        public event HlrTaskTest.TaskEventHandle TaskStoped;

        protected void OnTaskStoped()
        {
            if(this.TaskStoped!=null)
            {
                TaskStoped.BeginInvoke(this,new TaskEventArgs(TaskState.Stopped),new AsyncCallback(TaskEnded),null);
                //TaskStoped(this,new TaskEventArgs(TaskState.Stopped));
            }
        }

        private void TaskEnded(IAsyncResult ar)
        {
            this.TaskStoped.EndInvoke(ar);
            this.TaskStoped=null;
        }
    }
}

TaskManager
using System;
using System.Collections;

namespace HlrTaskTest
{
    /**//// <summary>
    /// TaskManager 的摘要说明。
    /// </summary>
    public class TaskManager
    {
        public TaskManager()
        {
             
        }

        public void  AddTask(ITask task)
        {
            if(!mTaskList.ContainsKey(task.TaskName.Trim()))
            {
                mTaskList.Add(task.TaskName.ToString().Trim(),task);
                task.BeginTask+=new TaskEventHandle(task_BeginTask);
                task.TaskStoped+=new TaskEventHandle(task_TaskStoped);    
                task.TaskState=TaskState.Run;
                Log.WriteLine("testLog",task.TaskName.ToString()+"添加");
            }
        }
    
        private Hashtable mTaskList=new Hashtable();
        public Hashtable TaskList
        {
            get
            {
                return mTaskList;
            }
        }
        
        public void RemoveTask(ITask task)
        {
            if(mTaskList.ContainsKey(task.TaskName.Trim()))
            {
                mTaskList.Remove(task.TaskName.Trim());
                task.BeginTask-=new TaskEventHandle(task_BeginTask);
                Log.WriteLine("testLog",task.TaskName.ToString()+"删除");
            }
        }

        private void task_BeginTask(object o, TaskEventArgs e)
        {
            //执行任务，与boss数据比对，然后，在删除任务库中的数据
            if(((Task)o).TaskName=="西门子")
            {
                System.Threading.Thread.Sleep(60*1000);//西门子的时候，时间弄一分钟，模拟表示西门子处理时间很长。
            }
            else
                System.Threading.Thread.Sleep(20*1000);
            Log.WriteLine("testLog",((Task)o).TaskName.ToString()+"开始");
        }

        private void task_TaskStoped(object o, TaskEventArgs e)
        {
            RemoveTask((ITask)o);
        }
    }
}

使用了下事件,因此,现在记录下一般的写法:
首先
定义一个委托
public delegate void  TaskEventHandle(object o,TaskEventArgs e);

TaskEventArgs
委托中的TaskEventArgs 参数

public class TaskEventArgs:EventArgs
    {

        private TaskState mTaskState;
        public TaskEventArgs(TaskState taskState)
        {
            this.mTaskState=taskState;
        }
        public TaskState TaskState
        {
            get
            {
                return this.mTaskState;
            }
        }
    }

BeginTask

定义一个事件
public event HlrTaskTest.TaskEventHandle BeginTask;

并写一个保护方法
protected void OnBeginTask()
        {
            if(this.BeginTask!=null)
            {
                BeginTask.BeginInvoke(this,new TaskEventArgs(TaskState.Run),
                    new AsyncCallback(TaskRunToEnd),null);
                //    BeginTask(this,new TaskEventArgs(TaskState.Run));
            }
        }

由于这个地方使用了回调函数,BeginInvoke参数中的最后一个参数,不知道写什么,所以，用的null
则需要写一个回调函数
private  void TaskRunToEnd(IAsyncResult ar)
        {
            this.TaskState=TaskState.Stopped;
        }

转载于:https://www.cnblogs.com/yanchanggang/archive/2008/01/08/1030128.html