/// <summary>
        /// 同步模式:处理
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public override object DoExecuteMessageRequest(string serviceName, WQMessage msg, bool async)
        {
            //1. 保存DB,返回msg.TranscactionID
            //2. 异步调用同步方法
            //3. 开启守护线程修补失败的
            Log.Write(LogAction.Info, className, "DoExecuteMessageRequest", serviceName, -1, string.Format(startFormat, serviceName, msg.TransactionID));
            Routing routing = Routing(serviceName, msg);
            if (null == routing || routing.EmptyHandlerName.Length > 0)
            {
                return EmptyRouting(serviceName, msg, async);
            }
            int rtn = -1;
            msg.ServiceName = serviceName;
            long pidx = routing.ParentGroupIndex;
            long idx = routing.GroupIndex;
            rtn = MessageDao.Save(serviceName, msg, (int)DealStatus.Dealing, pidx, idx);
            Log.Write(LogAction.Info, className, "DoExecuteMessageRequest", serviceName, -1, msg.TransactionID + ",保存消息返回值:" + rtn);
            if (rtn > 0)
            {
                AsyncDelegate ad = new AsyncDelegate(AsyncExecute);
                ad.BeginInvoke(serviceName, pidx, idx, msg, null, null);
            }
            return (rtn > 0);

        }

 public void BeginInvoke(AsyncDelegate del)
 {
     ControllerMainAction mainAction = new SimpleDefaultMainAction(this, del);
     try
     {
         if (!View.IsHandleCreated)
         {
             return;
         }
         View.BeginInvoke(new AsyncDelegate(mainAction.run), null);
     }
     catch (ObjectDisposedException)
     {
         //happens because there is no synchronization between the lifecycle of a form and callbacks of background threads.
         //catch silently
     }
 }

    /// <summary>
    /// Initiates the asynchronous execution of the SQL statement or stored procedure 
    /// that is described by this <see cref="MySqlCommand"/>. 
    /// </summary>
    /// <returns>An <see cref="IAsyncResult"/> that can be used to poll or wait for results, 
    /// or both; this value is also needed when invoking <see cref="EndExecuteNonQuery"/>, 
    /// which returns the number of affected rows. </returns>
    public IAsyncResult BeginExecuteNonQuery()
    {
      if (caller != null)
        Throw(new MySqlException(Resources.UnableToStartSecondAsyncOp));

      caller = new AsyncDelegate(AsyncExecuteWrapper);
      asyncResult = caller.BeginInvoke(2, CommandBehavior.Default, null, null);
      return asyncResult;
    }

    /// <summary>
    /// Initiates the asynchronous execution of the SQL statement or stored procedure 
    /// that is described by this <see cref="MySqlCommand"/> using one of the 
    /// <b>CommandBehavior</b> values. 
    /// </summary>
    /// <param name="behavior">One of the <see cref="CommandBehavior"/> values, indicating 
    /// options for statement execution and data retrieval.</param>
    /// <returns>An <see cref="IAsyncResult"/> that can be used to poll, wait for results, 
    /// or both; this value is also needed when invoking EndExecuteReader, 
    /// which returns a <see cref="MySqlDataReader"/> instance that can be used to retrieve 
    /// the returned rows. </returns>
    public IAsyncResult BeginExecuteReader(CommandBehavior behavior)
    {
      if (caller != null)
        Throw(new MySqlException(Resources.UnableToStartSecondAsyncOp));

      caller = new AsyncDelegate(AsyncExecuteWrapper);
      asyncResult = caller.BeginInvoke(1, behavior, null, null);
      return asyncResult;
    }

 public static void Write(LogEvent log)
 {
     try
     {
         AsyncDelegate ad = new AsyncDelegate(write);
         ad.BeginInvoke(log, new AsyncCallback(CallbackMethod), ad);
     }
     catch { }
 }

 public void Invoke(AsyncDelegate del)
 {
     Invoke(del, false);
 }

 private void Read()
 {
     AsyncDelegate read = new AsyncDelegate(ReadAsync);
     BeginInvoke(read);
 }

 protected void BeginInvoke(AsyncDelegate del)
 {
     del.BeginInvoke(EndInvoke, del);
 }

 private void Fail()
 {
     AsyncDelegate fail = new AsyncDelegate(FailAsync);
     BeginInvoke(fail);
 }

 private void Freeze()
 {
     AsyncDelegate freezeDelegate = new AsyncDelegate(FreezeAsync);
     BeginInvoke(freezeDelegate);
 }

 private void Create()
 {
     AsyncDelegate create = new AsyncDelegate(CreateAsync);
     BeginInvoke(create);
 }

 private void Connect()
 {
     AsyncDelegate connect = new AsyncDelegate(ConnectAsync);
     BeginInvoke(connect);
 }

 private void Commit()
 {
     AsyncDelegate commit = new AsyncDelegate(CommitAsync);
     BeginInvoke(commit);
 }

		/// <summary>
		/// Initiates the asynchronous execution of the SQL statement or stored procedure 
		/// that is described by this <see cref="MySqlCommand"/>. 
		/// </summary>
		/// <param name="callback">
		/// An <see cref="AsyncCallback"/> delegate that is invoked when the command's 
		/// execution has completed. Pass a null reference (<b>Nothing</b> in Visual Basic) 
		/// to indicate that no callback is required.</param>
		/// <param name="stateObject">A user-defined state object that is passed to the 
		/// callback procedure. Retrieve this object from within the callback procedure 
		/// using the <see cref="IAsyncResult.AsyncState"/> property.</param>
		/// <returns>An <see cref="IAsyncResult"/> that can be used to poll or wait for results, 
		/// or both; this value is also needed when invoking <see cref="EndExecuteNonQuery"/>, 
		/// which returns the number of affected rows. </returns>
		public IAsyncResult BeginExecuteNonQuery(AsyncCallback callback, object stateObject)
		{
			AsyncDelegate del = new AsyncDelegate(AsyncExecuteWrapper);
			asyncResult = del.BeginInvoke(2, CommandBehavior.Default, 
				callback, stateObject);
			return asyncResult;
		}

 private void Recover()
 {
     AsyncDelegate recover = new AsyncDelegate(RecoverAsync);
     BeginInvoke(recover);
 }

 private void Write()
 {
     AsyncDelegate write = new AsyncDelegate(WriteAsync);
     BeginInvoke(write);
 }

 public void Background(AsyncDelegate del, AsyncDelegate cleanup)
 {
     // Move to background thread
     background(new AsyncDelegateBackgroundAction(del, cleanup));
 }

 private void Abort()
 {
     AsyncDelegate abort = new AsyncDelegate(AbortAsync);
     BeginInvoke(abort);
 }

 private void Access()
 {
     AsyncDelegate access = new AsyncDelegate(AccessAsync);
     BeginInvoke(access);
 }

        public static void OpenAttachmentAsync(Control Ctrl, int AttachmentID, int ConnectionID)
        {
            Ctrl.UseWaitCursor = true;

            // Create the delegate.
            AsyncDelegate dlgt = new AsyncDelegate(Utils.OpenAttachment);

            // Initiate the asychronous call.  Include an AsyncCallback
            // delegate representing the callback method, and the data
            // needed to call EndInvoke.
            IAsyncResult ar = dlgt.BeginInvoke(Ctrl, AttachmentID, ConnectionID, new AsyncCallback(CallbackMethod), dlgt);
        }