public void DeliverMessage(ExternalDataEventArgs eventArgs, IComparable queueName, object message, object workItem, IPendingWork workHandler)
        {
            if (eventArgs == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("eventArgs");
            }
            if (queueName == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("queueName");
            }

            using (ExternalDataExchangeClient desClient = new ExternalDataExchangeClient(WorkflowRuntimeEndpoint.netNamedPipeContextBinding,
                new EndpointAddress(this.baseUri)))
            {
                using (OperationContextScope scope = new OperationContextScope((IContextChannel)desClient.InnerChannel))
                {
                    IContextManager contextManager = desClient.InnerChannel.GetProperty<IContextManager>();
                    Fx.Assert(contextManager != null, "IContextManager must not be null.");
                    if (contextManager != null)
                    {
                        IDictionary<string, string> context = new Dictionary<string, string>();
                        context["instanceId"] = eventArgs.InstanceId.ToString();
                        contextManager.SetContext(context);
                    }

                    desClient.RaiseEvent(eventArgs, queueName, message);
                }
            }
  
        }

        private void onWorkflowActivated1_Invoked(object sender, ExternalDataEventArgs e)
        {
            Debug.WriteLine("admProcessRequestsWF:{" + workflowProperties.WorkflowId + "} initiated");
            item = workflowProperties.Item;

            startTime = DateTime.Now;
        }

        private void onWorkflowActivated1_Invoked(object sender, ExternalDataEventArgs e)
        {
            intZgloszenieID = Convert.ToInt32(workflowProperties.Item["Zgłoszenie.ID"]);

            Load_cNagrody();

            Clear_ContentEntries();
        }

 public void OnValuationRequest()
 {
     ExternalDataEventArgs e = new ExternalDataEventArgs(IgrssCommon.lastWf);
     if (RequestValuation != null)
     {
         RequestValuation(this, e);
     }
 }

        private void onWorkflowActivated1_Invoked(object sender, ExternalDataEventArgs e)
        {
            Debug.WriteLine("ZatwierdzenieZadaniaWF:{" + workflowProperties.WorkflowId + "} initiated");
            item = workflowProperties.Item;

            Debug.WriteLine("Workflow created:" + workflowProperties.Workflow.Created.ToString());
            startTime = DateTime.Now;
        }

        /// <summary>
        /// 接收事件后处理审批流程
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void SMTSubmitEvent_Invoked(object sender, ExternalDataEventArgs e)
        {
            SMTFlowArg input = e as SMTFlowArg;
            this.ApproveInfo = input.FlowData;
            Root().FlowData = input.FlowData;

            //Console.WriteLine("事件节点：" + this.Name + "工作流返回结果：" + ApproveInfo.Flow_FlowRecord_T.Content);
               //以下为处理代码
        }

 private void onTaskChanged1_Invoked(object sender, ExternalDataEventArgs e)
 {
     //更改后检查任务属性。
     //查找 1.0 以反映已完成的任务。
     if (afterProperties.PercentComplete == 1.0)
     {
         taskCompleted = true;
     }
 }

        private void onWorkflowActivated(object sender, ExternalDataEventArgs e)
        {
            // desiriarize xml to the instance
            workflowId = workflowProperties.WorkflowId;

            // set value
            assignee = System.Threading.Thread.CurrentPrincipal.Identity.Name;
            instructions = "";
        }

 private void Paied(object sender, ExternalDataEventArgs e)
 {
     CRySTALDataConnections.CRySTALDataSetTableAdapters.CustomerTransactionsTableAdapter cta = new CRySTALDataConnections.CRySTALDataSetTableAdapters.CustomerTransactionsTableAdapter();
     cta.SetStatus(false, false, e.InstanceId);
     CRySTALDataConnections.CRySTALDataSetTableAdapters.TablesTblTableAdapter tta = new CRySTALDataConnections.CRySTALDataSetTableAdapters.TablesTblTableAdapter();
     CRySTALDataConnections.CRySTALDataSet.CustomerTransactionsDataTable ctd;
     ctd = cta.GetDataByWorkflowInstID(e.InstanceId);
     if (ctd.Rows.Count == 0) return;
     tta.SetStatus(2, ctd.First().TableNumber);
 }

        private void OnEventInvoked(object sender, ExternalDataEventArgs e)
        {
            FormEventArgs args = (FormEventArgs)e;

            FormsWorkflow formsWorkflow = this.GetRoot<FormsWorkflow>();

            formsWorkflow.ChildWorkflowResult = args.WorkflowResult;

            base.OnInvoked(e);
        }

        private void AddFoodOrderToBill(object sender, ExternalDataEventArgs e)
        {
            CRySTAL.FoodOrder order = (e as WorkflowLocalService.FoodOrderEventArgs).Order;
            CRySTALDataConnections.CRySTALDataSetTableAdapters.BillItemsTableAdapter bia = new CRySTALDataConnections.CRySTALDataSetTableAdapters.BillItemsTableAdapter();
            CRySTAL.CrystalMenuDataContext db = new CRySTAL.CrystalMenuDataContext();

            foreach (CRySTAL.ItemOrder item in order.FoodOrders)
            {
                var product = from p in db.MenuItems
                              where p.ID == item.productID
                              select p;
                if (product.Count() > 0)
                {
                    bia.InsertBillItem(e.InstanceId, product.First().Name, (decimal)product.First().Price, item.DeleverToPerson);
                }
            }
        }

 public void EventHandler(object sender, ExternalDataEventArgs eventArgs)
 {
     if (eventArgs == null)
     {
         throw new ArgumentNullException("eventArgs");
     }
     try
     {
         object obj2;
         IPendingWork work;
         object[] objArray = this.enqueueWrapper.PrepareEventArgsArray(sender, eventArgs, out obj2, out work);
         EventQueueName key = this.GetKey(objArray);
         string name = null;
         if (eventArgs.Identity == null)
         {
             IIdentity identity = Thread.CurrentPrincipal.Identity;
             WindowsIdentity identity2 = identity as WindowsIdentity;
             if ((identity2 != null) && (identity2.User != null))
             {
                 name = identity2.User.Translate(typeof(NTAccount)).ToString();
             }
             else if (identity != null)
             {
                 name = identity.Name;
             }
             eventArgs.Identity = name;
         }
         else
         {
             name = eventArgs.Identity;
         }
         MethodMessage message = new MethodMessage(this.proxiedType, this.eventName, objArray, name);
         WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "Firing event {0} for instance {1}", new object[] { this.eventName, eventArgs.InstanceId });
         this.enqueueWrapper.DeliverMessage(eventArgs, key, message, obj2, work);
     }
     catch (Exception exception)
     {
         if (ExternalDataExchangeService.IsIrrecoverableException(exception))
         {
             throw;
         }
         throw new EventDeliveryFailedException(SR.GetString("Error_EventDeliveryFailedException", new object[] { this.proxiedType, this.eventName, eventArgs.InstanceId }), exception);
     }
 }

        public void EventHandler(object sender, ExternalDataEventArgs eventArgs)
        {
            if (eventArgs == null)
            {
                throw new ArgumentNullException("eventArgs");
            }

            try
            {
                object workItem;
                IPendingWork workHandler;
                object[] args = this.enqueueWrapper.PrepareEventArgsArray(sender, eventArgs, out workItem, out workHandler);
                EventQueueName key = GetKey(args);

                String securityIdentifier = null;
                if (eventArgs.Identity == null)
                {
                    IIdentity identity = System.Threading.Thread.CurrentPrincipal.Identity;
                    WindowsIdentity windowsIdentity = identity as WindowsIdentity;
                    if (windowsIdentity != null && windowsIdentity.User != null)
                        securityIdentifier = windowsIdentity.User.Translate(typeof(NTAccount)).ToString();
                    else if (identity != null)
                        securityIdentifier = identity.Name;

                    eventArgs.Identity = securityIdentifier;
                }
                else
                {
                    securityIdentifier = eventArgs.Identity;
                }

                MethodMessage message = new MethodMessage(this.proxiedType, this.eventName, args, securityIdentifier);

                WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "Firing event {0} for instance {1}", this.eventName, eventArgs.InstanceId);

                this.enqueueWrapper.DeliverMessage(eventArgs, key, message, workItem, workHandler);
            }
            catch (Exception e)
            {
                if (ExternalDataExchangeService.IsIrrecoverableException(e))
                {
                    throw;
                }
                else
                {
                    throw new EventDeliveryFailedException(SR.GetString(SR.Error_EventDeliveryFailedException, this.proxiedType, this.eventName, eventArgs.InstanceId), e);
                }
            }
        }

        private void onAGMReviewTaskChanged_Invoked(object sender, ExternalDataEventArgs e)
        {
            if (onAGMReviewTaskChanged.AfterProperties.ExtendedProperties[statusFieldID] != null)
            {
                string taskStatus = onAGMReviewTaskChanged.AfterProperties.ExtendedProperties[statusFieldID].ToString();

                if (taskStatus != null)
                {
                    if ((taskStatus == "Completed") || (taskStatus == "Expired"))
                    {
                        this._isAGMReviewTaskComplete = true;
                    }
                }
            }
        }

        private void onWorkflowActivated1_Invoked(object sender, ExternalDataEventArgs e)
        {
            using (StringReader stringReader = new StringReader(workflowProperties.InitiationData))
            {
                using (XmlReader reader = XmlReader.Create(stringReader))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(ReviewWFData));
                    WorkflowData = (ReviewWFData)serializer.Deserialize(reader);
                }
            }

            SetReviewers();
            SetAgendaTitle();

            notifyAgendaOwner.Action = "Complete";
            notifyAgendaOwner.Source = "Paperless Board";
            notifyAgendaOwner.TaskTitle = string.Format("Edit documents for '{0}', and then start the Board Agenda Workflow.", AgendaTitle);
            notifyAgendaOwner.TaskDescription = string.Format("All the reviewers have finished reviewing content for this agenda. The Review Agenda workflow has been completed for Agenda {0}. The owner/sponsor of this agenda item now needs to start the Board Agenda workflow for this agenda.", AgendaTitle);
            notifyAgendaOwner.TaskDueDate = DateTime.Today.AddDays(1);

            SPUser originator = GetSPUser(this.workflowProperties.Item, "Sponsor");
            notifyAgendaOwner.TaskAssignedTo = originator.LoginName;
        }

 private void onWorkflowActivated1_Invoked(object sender, ExternalDataEventArgs e)
 {
     using (StringReader stringReader = new StringReader(workflowProperties.InitiationData))
     {
         using (XmlReader reader = XmlReader.Create(stringReader))
         {
             XmlSerializer serializer = new XmlSerializer(typeof(DigitalSignaturesWFData));
             WorkflowData = (DigitalSignaturesWFData)serializer.Deserialize(reader);
         }
     }
     SetAgendaTitle();
 }

 private void onWorkflowActivated1_Invoked(object sender, ExternalDataEventArgs e)
 {
     Debug.WriteLine("wfPrzygotujWiadomoscDlaKlienta - ACTIVATED");
     item = workflowProperties.Item;
 }

        void EndNotify(object sender, ExternalDataEventArgs e)
        {
            SubmitEventArgs input = e as SubmitEventArgs;

               this.提交结果 = input.提交结果;
               this.提交人员 = input.提交人员;
               this.提交部门 = input.提交部门;
               this.提交职能 = input.提交职能;
               this.提交日期 = System.DateTime.Now;
               this.提交方式 = input.提交方式;
               this.提交说明 = input.提交说明;
               this.触发器类型 = input.触发器类型;

               this.下一状态办理人员 = input.下一状态办理人员;

               Root().当前节点提交结果 = input.提交结果;
               Root().当前节点提交人员 = input.提交人员;
               Root().状态编号 = input.状态实例编号.ToString();
               Root().状态跟踪器 = 1;
        }

 private void OnAddInvestigationDetails_Invoked(object sender, ExternalDataEventArgs e)
 {
     string curUser = Thread.CurrentPrincipal.Identity.Name;
     AddInvestigationDetailsEventArgs args = (AddInvestigationDetailsEventArgs) e;
     IgrssAdapters.InvestigationAdapter.AddInvestigationDetail(Guid.NewGuid(), ComplainId, args.InvestigationDate, args.InvestigationDetails, curUser, DateTime.Now);
 }

        private void OnReAssignInvestigation_Invoked(object sender, ExternalDataEventArgs e)
        {
            InvestigationRequiredEventArgs args = (InvestigationRequiredEventArgs) e;
            Guid EmployeeId = (Guid)IgrssAdapters.EmployeeMaster.GetEmployeeIdByUsername(args.InvestigatingOfficer);
            IgrssAdapters.ComplainAdapter.AssignEnquiryOfficer(EmployeeId, DateTime.Now, ComplainId);
            string curUser = Thread.CurrentPrincipal.Identity.Name;

            string link = WorkflowLinks.Default.ComplainInvestigationResult;
            Dictionary<string, object> InfoList = new Dictionary<string, object>();
            InfoList.Add("FileId", ComplainId);
            Guid GroupId = Guid.NewGuid();
            WorkflowSupport.SendAlert(curUser, args.InvestigatingOfficer, link, "Complain Investigation Required!", InfoList,GroupId);
        }