同事写的异步调用网络编程

同事写的异步调用网络编程

这里只是做个备份:

 

   ...{
if (CmbServer.Text == "")
            ...{
                return;
            }
            BtnSearch.Enabled = false;
            this.RoleInfoView.DataSource = null;

            Enum.Message_Body[] mContent = new Enum.Message_Body[3];

            mContent[0].eName = Enum.TagName.FJ_UserID;
            mContent[0].eFormat =  Enum.TagFormat.TLV_STRING;
            mContent[0].oContent = TxtAccount.Text;

            mContent[1].eName = Enum.TagName.FJ_ServerIP;
            mContent[1].eFormat =  Enum.TagFormat.TLV_STRING;
            mContent[1].oContent = Operation_FJ.GetItemAddr(mServerInfo, CmbServer.Text);


            mContent[2].eName = Enum.TagName.ServerInfo_City;
            mContent[2].eFormat =  Enum.TagFormat.TLV_STRING;
            mContent[2].oContent = CmbServer.Text;

            查询角色信息#region 查询角色信息
            ThreadTesk.Task th_Tesk_Search = new ThreadTesk.Task(SearchGMUser, this);
            th_Tesk_Search.StartTask(new ThreadTesk.DelegateGetResult(op_FJ.GetResult), Enum.ServiceKey.FJ_GMUser_Query, mContent);
            #endregion
        }
        查询角色信息#region 查询角色信息
        void SearchGMUser(Enum.Message_Body[,] mResult)
        ...{
            BtnSearch.Enabled = true;
            if (mResult[0, 0].eName == Enum.TagName.ERROR_Msg)
            ...{
                MessageBox.Show(mResult[0, 0].oContent.ToString());
                return;
            }
            Operation_FJ.BuildDataTable(this.m_ClientEvent, mResult, RoleInfoView, out iPageCount);
        }
        #endregion

 ThreadTesk程序如下:

 

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace ThreadTesk
...{
    任务工作状态#region 任务工作状态
    /**//// <summary>
    /// 任务工作状态
    /// </summary>
    public enum TaskStatus
    ...{
        /**//// <summary>
        /// 任务没有运行,可能是工作进程没有开始、工作进程正常结束或正常取消工作进程
        /// </summary>
        Stopped,
        /**//// <summary>
        /// 任务没有运行,被调用者强行中止
        /// </summary>
        Aborted,
        /**//// <summary>
        /// 任务没有运行,在工作进程中触发错误而中止
        /// </summary>
        ThrowErrorStoped,
        /**//// <summary>
        /// 任务运行中
        /// </summary>
        Running,
        /**//// <summary>
        /// 尝试取消工作进程中
        /// </summary>
        CancelPending,
        /**//// <summary>
        /// 强行中止工作进程中
        /// </summary>
        AbortPending

    }
    #endregion

    状态事件#region 状态事件
    /**//// <summary>
    /// 任务状态消息
    /// </summary>
    public class TaskEventArgs : EventArgs
    ...{
        /**//// <summary>
        /// 任务运行结果
        /// </summary>
        public Object Result;
        /**//// <summary>
        /// 任务进度(0-100)
        /// </summary>
        public int Progress;
        /**//// <summary>
        /// 任务工作状态
        /// </summary>
        public TaskStatus Status;
        /**//// <summary>
        /// 任务消息文本
        /// </summary>
        public String Message;
        /**//// <summary>
        /// 创建任务状态消息
        /// </summary>
        /// <param name="progress">任务进度(0-100)</param>
        public TaskEventArgs(int progress)
        ...{
            this.Progress = progress;
            this.Status = TaskStatus.Running;
        }
        /**//// <summary>
        /// 创建任务状态消息
        /// </summary>
        /// <param name="status">任务线程状态</param>
        public TaskEventArgs(TaskStatus status)
        ...{
            this.Status = status;
        }
        /**//// <summary>
        /// 创建任务状态消息
        /// </summary>
        /// <param name="progress">任务进度(0-100)</param>
        /// <param name="result">任务运行中间结果</param>
        public TaskEventArgs(int progress, object result)
        ...{
            this.Progress = progress;
            this.Status = TaskStatus.Running;
            this.Result = result;
        }
        /**//// <summary>
        /// 创建任务状态消息
        /// </summary>
        /// <param name="status">任务线程状态</param>
        /// <param name="result">任务运行结果</param>
        public TaskEventArgs(TaskStatus status, object result)
        ...{
            this.Status = status;
            this.Result = result;
        }
        /**//// <summary>
        /// 创建任务状态消息
        /// </summary>
        /// <param name="status">任务线程状态</param>
        /// <param name="message">消息文本</param>
        /// <param name="result">任务运行结果</param>
        public TaskEventArgs(TaskStatus status, string message, object result)
        ...{
            this.Status = status;
            this.Message = message;
            this.Result = result;
        }
        /**//// <summary>
        /// 创建任务状态消息
        /// </summary>
        /// <param name="progress">任务进度(0-100)</param>
        /// <param name="message">消息文本</param>
        /// <param name="result">任务运行中间结果</param>
        public TaskEventArgs(int progress, string message, object result)
        ...{
            this.Progress = progress;
            this.Status = TaskStatus.Running;
            this.Message = message;
            this.Result = result;
        }
        /**//// <summary>
        /// 创建任务状态消息
        /// </summary>
        /// <param name="status">任务线程状态</param>
        /// <param name="progress">任务进度(0-100)</param>
        /// <param name="message">消息文本</param>
        /// <param name="result">任务运行中间结果</param>
        public TaskEventArgs(TaskStatus status, int progress, string message, object result)
        ...{
            this.Status = status;
            this.Progress = progress;
            this.Message = message;
            this.Result = result;
        }
    }
    #endregion

    委托#region 委托
    public delegate void InvokeServer(Enum.Message_Body[,] mResult); 
    /**//// <summary>
    /// API获取相关数据
    /// 传入值:ServiceKey,Message_Body[]
    /// 返回值:Message_Body[,]
    /// </summary>
    /// <param name="mkey">ServiceKey</param>
    /// <param name="mContent">Message_Body[]</param>
    /// <returns>API获取相关数据</returns>
    public delegate Enum.Message_Body[,] DelegateGetResult(Enum.ServiceKey mkey,Enum.Message_Body[] mContent);
    /**//// <summary>
    /// 获取服务器列表
    /// 传入值:Message_Body[]
    /// 返回值:Message_Body[,]
    /// </summary>
    /// <param name="mContent">Message_Body[]</param>
    /// <returns>获取服务器列表</returns>
    public delegate Enum.Message_Body[,] DelegateGetList(Enum.Message_Body[] mContent);
    /**//// <summary>
    /// 获取相关数据
    /// 传入值:ServiceKey,Message_Body[],MsgCategory msgcategory
    /// 返回值:Message_Body[,]
    /// </summary>
    /// <param name="mkey">ServiceKey</param>
    /// <param name="msgcategory">MsgCategory msgcategory</param>
    /// <param name="mContent">Message_Body[]</param>
    /// <returns>获取相关数据</returns>
    public delegate Enum.Message_Body[,] DelegateGetResultApi(Enum.ServiceKey mkey, Enum.MsgCategory msgcategory, Enum.Message_Body[] mContent);
    /**//// <summary>
    /// 任务事件的委托接口
    /// </summary>
    public delegate void TaskEventHandler(object sender, TaskEventArgs e);
    #endregion

    工作线程#region 工作线程
    /**//// <summary>
    /// 工作线程
    /// </summary>
    public class Task
    ...{
        变量#region 变量
        /**//// <summary>
        /// 任务调用线程(前台或UI线程)
        /// </summary>
        /// 
        //protected System.Threading.Thread _callThread = null;
        /**//// <summary>
        /// 任务工作线程(后台)
        /// </summary>
        //protected System.Threading.Thread _workThread = null;
        /**//// <summary>
        /// 任务工作状态
        /// </summary>
        
        protected TaskStatus _taskState = TaskStatus.Stopped;
        /**//// <summary>
        /// 任务进度(0-100)
        /// </summary>
        protected int _progress = -1;
        /**//// <summary>
        /// 任务工作结果
        /// </summary>
        protected Enum.Message_Body[,] _result = null;
        /**//// <summary>
        /// 任务工作进程出错时,捕获的异常对象
        /// </summary>
        protected Exception _exception = null;

        private  InvokeServer _iServer;

        private Hashtable HashTread = new Hashtable();
        private System.Windows.Forms.Form _form;
        #endregion

        构造函数#region 构造函数
        public Task(InvokeServer iServer, System.Windows.Forms.Form form)
        ...{
            _iServer = iServer;
            _form = form;
        }
        #endregion

        线程状态判断#region 线程状态判断
        protected bool IsStop
        ...{
            get
            ...{
                bool result = false;
                switch (_taskState)
                ...{
                    case TaskStatus.Stopped:
                    case TaskStatus.Aborted:
                    case TaskStatus.ThrowErrorStoped:
                        result = true;
                        break;
                    default:
                        break;
                }
                return result;
            }
        }
        #endregion

        工作进程管理#region 工作进程管理

        /**//// <summary>
        /// API获取相关数据
        /// </summary>
        /// <param name="getResultApi"></param>
        /// <param name="mkey"></param>
        /// <param name="mContent"></param>
        /// <param name="msgcategory"></param>
        /// <returns></returns>
        public bool StartTask(DelegateGetResultApi getResultApi, Enum.ServiceKey mkey,Enum.MsgCategory msgcategory ,Enum.Message_Body[] mContent)
        ...{
            bool result = false;
            lock (this)
            ...{
                if (IsStop && getResultApi != null)
                ...{
                    _result = null;
                    System.Threading.Thread _callThread = System.Threading.Thread.CurrentThread;
                    HashTread.Add(System.Threading.Thread.CurrentThread.ManagedThreadId, _iServer);
                    // 开始工作方法进程,异步开启,传送回调方法
                    getResultApi.BeginInvoke(mkey, msgcategory,mContent, new AsyncCallback(EndWorkBackApi), getResultApi);
                    // 更新任务工作状态
                    _taskState = TaskStatus.Running;
                    // 触发任务工作状态变化事件
                    //FireStatusChangedEvent(_taskState, null);
                    result = true;
                }
            }
            return result;
        }
        /**//// <summary>
        /// 获取相关数据
        /// </summary>
        /// <param name="getResult"></param>
        /// <param name="mkey"></param>
        /// <param name="mContent"></param>
        /// <returns></returns>
        public bool StartTask(DelegateGetResult getResult, Enum.ServiceKey mkey,Enum.Message_Body[] mContent)
        ...{
            bool result = false;
            lock (this)
            ...{
                if (IsStop && getResult != null)
                ...{
                    _result = null;
                    System.Threading.Thread _callThread = System.Threading.Thread.CurrentThread;
                    HashTread.Add(System.Threading.Thread.CurrentThread.ManagedThreadId, _iServer);
                    // 开始工作方法进程,异步开启,传送回调方法
                    getResult.BeginInvoke(mkey, mContent, new AsyncCallback(EndWorkBack), getResult);
                    // 更新任务工作状态
                    _taskState = TaskStatus.Running;
                    // 触发任务工作状态变化事件
                    //FireStatusChangedEvent(_taskState, null);
                    result = true;
                }
            }
            return result;
        }

        /**//// <summary>
        /// 获取服务器列表
        /// </summary>
        /// <param name="getResultApi"></param>
        /// <param name="mkey"></param>
        /// <param name="mContent"></param>
        /// <returns></returns>
        public bool StartTask(DelegateGetList getList,Enum.Message_Body[] mContent)
        ...{
            bool result = false;
            lock (this)
            ...{
                if (IsStop && getList != null)
                ...{
                    _result = null;
                    System.Threading.Thread _callThread = System.Threading.Thread.CurrentThread;
                    HashTread.Add(System.Threading.Thread.CurrentThread.ManagedThreadId, _iServer);
                    // 开始工作方法进程,异步开启,传送回调方法
                    getList.BeginInvoke(mContent, new AsyncCallback(EndWorkBackList), getList);
                    // 更新任务工作状态
                    _taskState = TaskStatus.Running;
                    // 触发任务工作状态变化事件
                    //FireStatusChangedEvent(_taskState, null);
                    result = true;
                }
            }
            return result;
        }
        #endregion

        回调方法#region 回调方法
        /**//// <summary>
        /// 工作方法完成后的回调方法
        /// 将检查是否出错,并获取、更新返回结果值
        /// </summary>
        /// <param name="ar">异步调用信号对象</param>
        protected void EndWorkBackApi(IAsyncResult ar)
        ...{
            
            try 
            ...{
                DelegateGetResultApi del = (DelegateGetResultApi)ar.AsyncState;
                _result = del.EndInvoke(ar);
                _form.Invoke(_iServer, _result);
                System.Threading.Thread _workThread = System.Threading.Thread.CurrentThread;
                //_workThread.Abort();  
            }
            catch
            ...{}
            
        }
        protected void EndWorkBackList(IAsyncResult ar)
        ...{
            try
            ...{
                DelegateGetList del = (DelegateGetList)ar.AsyncState;
                _result = del.EndInvoke(ar);
                _form.Invoke(_iServer, _result);
                System.Threading.Thread _workThread = System.Threading.Thread.CurrentThread;
                _workThread.Abort();  
            }
            catch
            ...{}
        }
        protected void EndWorkBack(IAsyncResult ar)
        ...{
            try
            ...{
                DelegateGetResult del = (DelegateGetResult)ar.AsyncState;
                _result = del.EndInvoke(ar);
                _form.Invoke(_iServer, _result);
                System.Threading.Thread _workThread = System.Threading.Thread.CurrentThread;
            }
            catch
            ...{ }
        }
        #endregion
    }
    #endregion
}