坚持学习WF(6):开发可复用的宿主程序

我们之前写工作流宿主程序一般都是直接写在program.cs文件里，这样复用性比较差。我们就简单的写两个类，这两个类主要实现的是对WorkflowInstance和WorkflowRuntime的封装。我们以后的例子都会使用这两个类。

第一个类是WorkflowInstanceWrapper，代码如下：

 
 

  
  [Serializable]
    public class
  
   WorkflowInstanceWrapper
    {
        private
  
   WorkflowInstance _workflowInstance;
        private ManualResetEvent _waitHandle = new ManualResetEvent(false
  
  );
        private Dictionary<String, Object> _outputParameters= new
  
   Dictionary
                <string, object>
  
  ();
        private
  
   Exception _exception;
        private String _reasonSuspended =
  
   String.Empty;

        public
  
   WorkflowInstanceWrapper(WorkflowInstance instance)
        {
            _workflowInstance =
  
   instance;
        }        
        public
  
   Guid Id
        {
            get
  
  
            {
                
  
  if (_workflowInstance != null
  
  )
                   return
  
   _workflowInstance.InstanceId;
                else
  
  
                   
  
  return
  
   Guid.Empty;
            }
        }        
        public Dictionary<String, Object>
  
   OutputParameters
        {
            get { return
  
   _outputParameters; }
            set { _outputParameters =
  
   value; }
        }        
        public
  
   ManualResetEvent WaitHandle
        {
            get { return
  
   _waitHandle; }
            set { _waitHandle =
  
   value; }
        }        
        public
  
   Exception Exception
        {
            get { return
  
   _exception; }
            set { _exception =
  
   value; }
        }        
        public
  
   String ReasonSuspended
        {
            get { return
  
   _reasonSuspended; }
            set { _reasonSuspended =
  
   value; }
        }        
        public
  
   WorkflowInstance WorkflowInstance
        {
            get { return
  
   _workflowInstance; }
        }        
        public void
  
   StopWaiting()
        {
            _waitHandle.Set();
        }
    }
 
 
1._exception,_reasonSuspended：表示当工作流非正常终止或挂起时的相关信息。

2. OutputParameters：用来接收工作流的输出参数，工作流运行时引擎将引发 WorkflowCompleted事件。

工作流运行时引擎将在WorkflowCompletedEventArgs 中传入工作流的所有输出参数。 这些参数包括工作

流的 out 和 ref 参数。
 

第二类是WorkflowManager代码如下：  

 public class  WorkflowRuntimeManager : IDisposable
    {
        private  WorkflowRuntime _workflowRuntime;
        private Dictionary<Guid, WorkflowInstanceWrapper>  _workflows
                               = new Dictionary<Guid, WorkflowInstanceWrapper> ();
      
        public  WorkflowRuntimeManager(WorkflowRuntime instance)
        {
            _workflowRuntime =  instance;
            if (instance == null )
            {
                throw new  NullReferenceException(
                    "A non-null WorkflowRuntime instance is required" );
            }            
            SubscribeToEvents(instance);
        }

      
        public  WorkflowInstanceWrapper StartWorkflow(Type workflowType,
            Dictionary<String, Object>  parameters)
        {
            WorkflowInstance instance =  _workflowRuntime.CreateWorkflow(
                workflowType, parameters);
            WorkflowInstanceWrapper wrapper
                =  AddWorkflowInstance(instance);
            instance.Start();
            return  wrapper;
        }
        
        public  WorkflowInstanceWrapper StartWorkflow(String markupFileName,
            String rulesMarkupFileName,
            Dictionary<String, Object>  parameters)
        {
            WorkflowInstance instance = null ;
            WorkflowInstanceWrapper wrapper = null ;
            XmlReader wfReader = null ;
            XmlReader rulesReader = null ;
            try
            {
                wfReader  =  XmlReader.Create(markupFileName);
                if (! String.IsNullOrEmpty(rulesMarkupFileName))
                {
                    rulesReader =  XmlReader.Create(rulesMarkupFileName);
                    instance =  _workflowRuntime.CreateWorkflow( wfReader, rulesReader, parameters);
                }
                else
                {
                    instance  = _workflowRuntime.CreateWorkflow(wfReader, null , parameters);
                }
                wrapper =  AddWorkflowInstance(instance);
                instance.Start();
            }
            finally
            {
                 if (wfReader != null )
                {
                    wfReader.Close();
                }
                if (rulesReader != null )
                {
                    rulesReader.Close();
                }
            }
            return  wrapper;
        }

       public  WorkflowRuntime WorkflowRuntime
        {
            get { return  _workflowRuntime; }
        }        
        public Dictionary<Guid, WorkflowInstanceWrapper>  Workflows
        {
            get { return  _workflows; }
        }        
        public event EventHandler<WorkflowLogEventArgs>  MessageEvent;    

       
        public void  ClearWorkflow(Guid workflowId)
        {
            if  (_workflows.ContainsKey(workflowId))
            {
                _workflows.Remove(workflowId);
            }
        }
      
        public void  ClearAllWorkflows()
        {
            _workflows.Clear();
        }
       
        private  WorkflowInstanceWrapper AddWorkflowInstance(
            WorkflowInstance instance)
        {
            WorkflowInstanceWrapper wrapper = null ;
            if (! _workflows.ContainsKey(instance.InstanceId))
            {
                wrapper = new  WorkflowInstanceWrapper(instance);
                _workflows.Add(wrapper.Id, wrapper);
            }
            return  wrapper;
        }
     
        public  WorkflowInstanceWrapper FindWorkflowInstance(Guid workflowId)
        {
            WorkflowInstanceWrapper result = null ;
            if  (_workflows.ContainsKey(workflowId))
            {
                result =  _workflows[workflowId];
            }
            return  result;
        }
       
        public void  WaitAll(Int32 msecondsTimeout)
        {
            if (_workflows.Count > 0 )
            {
                WaitHandle[] handles = new  WaitHandle[_workflows.Count];
                Int32 index = 0 ;
                foreach  (WorkflowInstanceWrapper wrapper
                    in  _workflows.Values)
                {
                    handles[index] =  wrapper.WaitHandle;
                    index++ ;
                }
                WaitHandle.WaitAll(handles, msecondsTimeout, false );
            }
        }
     
        public void  Dispose()
        {
            if (_workflowRuntime != null )
            {
                _workflowRuntime.StopRuntime();
                _workflowRuntime.Dispose();
            }
            ClearAllWorkflows();
        }
      
        private void  SubscribeToEvents(WorkflowRuntime runtime)
        {
            runtime.Started += new EventHandler<WorkflowRuntimeEventArgs> ( runtime_Started);
            runtime.Stopped += new EventHandler<WorkflowRuntimeEventArgs> (runtime_Stopped);
            runtime.WorkflowAborted+= ......
            runtime.WorkflowCompleted +=  ......
            runtime.WorkflowCreated += ......    
            ............
        }

        void runtime_Started(object  sender, WorkflowRuntimeEventArgs e)
        {
            LogStatus(Guid.Empty, "Started" );
        }
        void runtime_Stopped(object  sender, WorkflowRuntimeEventArgs e)
        {
            LogStatus(Guid.Empty, "Stopped" );
        }
        void runtime_WorkflowCreated(object  sender, WorkflowEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowCreated" );
        }
        void runtime_WorkflowStarted(object  sender, WorkflowEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowStarted" );
        }
        void runtime_WorkflowIdled(object  sender, WorkflowEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowIdled" );
        }

        void runtime_WorkflowCompleted(object  sender, WorkflowCompletedEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowCompleted" );
            WorkflowInstanceWrapper wrapper
                =  FindWorkflowInstance(e.WorkflowInstance.InstanceId);
            if (wrapper != null )
            {
                wrapper.OutputParameters =  e.OutputParameters;
                wrapper.StopWaiting();
            }
        }

        void runtime_WorkflowTerminated(object  sender,
            WorkflowTerminatedEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowTerminated" );
            WorkflowInstanceWrapper wrapper =  FindWorkflowInstance(e.WorkflowInstance.InstanceId);
            if (wrapper != null )
            {
                wrapper.Exception =  e.Exception;
                wrapper.StopWaiting();
            }
        }

        void runtime_WorkflowSuspended(object  sender, WorkflowSuspendedEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowSuspended" );
            WorkflowInstanceWrapper wrapper =  FindWorkflowInstance(e.WorkflowInstance.InstanceId);
            if (wrapper != null )
            {
                wrapper.ReasonSuspended =  e.Error;
            }
        }

        void runtime_WorkflowResumed(object  sender, WorkflowEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowResumed" );
        }
        void runtime_WorkflowPersisted(object  sender, WorkflowEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowPersisted" );
        }
        void runtime_WorkflowLoaded(object  sender, WorkflowEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowLoaded" );
        }
        void runtime_WorkflowAborted(object  sender, WorkflowEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowAborted" );
            WorkflowInstanceWrapper wrapper
                =  FindWorkflowInstance(e.WorkflowInstance.InstanceId);
            if (wrapper != null )
            {
                wrapper.StopWaiting();
            }
        }

        void runtime_WorkflowUnloaded(object  sender, WorkflowEventArgs e)
        {
            LogStatus(e.WorkflowInstance.InstanceId, "WorkflowUnloaded" );
        }

        private void  LogStatus(Guid instanceId, String msg)
        {
            if (MessageEvent != null )
            {
                String formattedMsg;
                if (instanceId ==  Guid.Empty)
                {
                    formattedMsg = String.Format("Runtime - {0}" , msg);
                }
                else
                {
                    formattedMsg  = String.Format("{0} - {1}" , instanceId, msg);
                }
                //raise the event
                MessageEvent(this, new  WorkflowLogEventArgs(formattedMsg));
            }
        }

    }   
    public class  WorkflowLogEventArgs : EventArgs
    {
        private String _msg =  String.Empty;
        public  WorkflowLogEventArgs(String msg)
        {
            _msg =  msg;
        }

        public  String Message
        {
            get { return  _msg; }
        }

1._workflows:一个key为Guid，value为WorkflowInstanceWrapper的字典。
2.SubscribeToEvent()：给workflowRuntime订阅事件.
3.StartWorkflow（）：实现创建，开始工作流.
4.MessageEvent：对Message进行格式化。
5.WaitAll（）用来挂起当前的线程直到所有的workflows完成，每个WorkflowInstanceWrapper有一个WaitHandle属性以便宿主程序能灵活控制。 

下面是测试代码：
 
 

  
  using
  
   (WorkflowRuntimeManager manager
        = new WorkflowRuntimeManager(new WorkflowRuntime("WorkflowRuntime"
  
  )))
{
   manager.MessageEvent += delegate
  
  (Object sender, WorkflowLogEventArgs e)
   {
      Console.WriteLine(e.Message);
   };
   manager.WorkflowRuntime.StartRuntime();
   Dictionary<String, Object> wfArguments= new Dictionary<string, object>
  
  ();
   wfArguments.Add("InputString", "one"
  
  );
   WorkflowInstanceWrapper instance =
  
   manager.StartWorkflow(
           typeof
  
  (SharedWorkflows.Workflow1), wfArguments);
   instance.WorkflowInstance.Terminate("Manually terminated"
  
  );
   instance.WaitHandle.WaitOne(10000, false
  
  );
   foreach
  
   (WorkflowInstanceWrapper wrapperin manager.Workflows.Values)
   {
       if (wrapper.OutputParameters.ContainsKey("Result"
  
  ))
       {
            Console.WriteLine(wrapper.OutputParameters["Result"
  
  ]);
       }
       if (wrapper.Exception != null
  
  )
       {
     Console.WriteLine("{0}-Exception:{1}"
  
  ,wrapper.Id,wrapper.Exception.Message);
       }
       if (wrapper.ReasonSuspended.Length > 0
  
  )
       {
    Console.WriteLine("{0}-Suspended: {1}"
  
  ,wrapper.Id, wrapper.ReasonSuspended);
       }
}    manager.ClearAllWorkflows();
 
 






















下面运行结果，从该结果可以清晰的看出工作流的执行过程：