首页 博客列表 精选博客 智能问答 chat-GPT 关于我
Windows Workflow开发演练
发布日期：2022-02-13 21:45:54 浏览次数：41 分类：技术文章

本文共 36587 字，大约阅读时间需要 121 分钟。

Windows Workflow
开发演练
 
 
Visual Studio 2005
中的工作流项目类型
l
         顺序工作流控制台应用程序 (Sequential Workflow Console Application)：创建用于生成工作流的项目,该工作流包含一个默认的顺序工作流和一个控制台测试宿主应用程序。
l
         顺序工作流库 (Sequential Workflow Library)：创建用于以库的形式生成顺序工作流的项目。
l
         工作流活动库 (Workflow Activity Library)：创建一个用来创建活动的库的项目，以后可以将其作为工作流应用程序中的构造块重用。
l
         状态机控制台应用程序 (State Machine Console Application)：创建用于生成状态机工作流和控制台宿主应用程序的项目。
l
         状态机工作流库 (State Machine Workflow Library)：创建用于以库的形式生成状态机工作流的项目。
这个例子我们完成一个最基础的工作流，在控制台上显示一些此工作流自身的信息。
这个练习我们学习工作流相关的基本操作。
 
新建项目，选择“顺序工作流控制台应用程序”：
从工具箱中拖一个
到设计器：
填写代码：
选择codeActivity1，点属性页，ExecuteCode属性输入方法名称showInfo，双击方法名，Visual studio自动生成方法代码框架，
填写代码：
   
public
sealed
partial
class
Workflow1:
SequentialWorkflowActivity
    {
……
       
private
void showInfo(
object sender,
EventArgs e)
        {
            CodeActivity c = (CodeActivity)sender;
           
Console
.WriteLine("Hello, from '{0}'./nI'm an instance of the {1} class.",
               c.Name, c.ToString());
            Console.ReadLine();
        }
    }
运行可以看到：
这个例子我们实现一个工作流，弹出消息框，显示从主程序接收到的数据。
这个练习我们学习如何通过参数传递数据到工作流。
 
让我们继续分析并修改该工作流，以使其在实例化以后接收和使用数据。有两种在实例化工作流以后使其接收数据的常规方法：参数和事件。如果选择使用参数，则需要在可视化设计器中手动定义参数名称和类型的列表。如果选择使用事件，则需要创建并添加一个自定义活动（该活动充当在工作流模型中的某个位置介入的外部源），并且传入一些数据。首先我们学习参数的使用，后面我们将说明基于事件的方法。
首先为
Workflow1
添加属性
FirstName
和
LastName
：
    public sealed partial class Workflow1: SequentialWorkflowActivity
    {
       ……
        private string _FirstName;
        public string FirstName
        {
            get { return _FirstName; }
            set { _FirstName = value; }
        }
        //{
        //   
数据可以保存到
UserData
中，如下：
        //    get { return (string)UserData["FirstName"];}
        //    set { UserData["FirstName"] = value; }
        //}
 
        private string _LastName;
        public string LastName
        {
            get { return _LastName; }
            set { _LastName = value; }
        }
……
}
 
在解决方案中新建一个
windows
应用程序
WinFormHost
，设计主窗体如下：
添加引用：
生成
tbStartWorkflow_Click
事件并填写代码（代码可以从
WorkflowConsoleApplication
的
program.cs
中复制得到
）：
using
System.Windows.Forms;
using
System.Threading;
using
System.Workflow.Runtime;
using
System.Workflow.Runtime.Hosting;
 
namespace
WinFormHost
{
    public partial class Form1 : Form
    {
……
        private void tbStartWorkflow_Click(object sender, EventArgs e)
        {
            using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
            {
                AutoResetEvent waitHandle = new AutoResetEvent(false);
                workflowRuntime.WorkflowCompleted += delegate(object sender1, WorkflowCompletedEventArgs e1) { waitHandle.Set(); };
                workflowRuntime.WorkflowTerminated += delegate(object sender1, WorkflowTerminatedEventArgs e1)
                {
                    Console.WriteLine(e1.Exception.Message);
                    waitHandle.Set();
                };
 
                Dictionary<string, object> parameters = new Dictionary<string, object>();
                parameters.Add("FirstName", tbFirstName.Text);
                parameters.Add("LastName", tbLastName.Text);
                WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(WorkflowConsoleApplication6.Workflow1), parameters);
                instance.Start();
 
                waitHandle.WaitOne();
            }
        }
    }
}
修改
Workflow1
的代码如下：
    public sealed partial class Workflow1: SequentialWorkflowActivity
    {
      ……
        private void showInfo(object sender, EventArgs e)
        {
            System.Windows.Forms.MessageBox.Show("Welcome, " + FirstName + " " + LastName);
        }
    }
运行
WinFormHost:
这个例子中我们写一个自动发送Mail的工作流，其中发送Mail由我们自定义的一个Activity实现。
这个练习我们学习如何实现自定义活动。
 
首先新建一个工作流Activity
库：SendMail
改名：
定义属性：
To
、
From
、
Subject
、
Body
、
Host
，改写方法
Execute:
    public partial class SendMailActivity: SequenceActivity
    {
        public String To
        {
            get { return _To; } set { _To = value; }
        }
        public String From
        {……}
        public String Subject
        {……}
        public String Body
        {……}
        public String Host
        {……}
 
        protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
        {
            MailAddress toAddress = new MailAddress(To);
            MailAddress fromAddress = new MailAddress(From);
 
            MailAddressCollection addresses = new MailAddressCollection();
            addresses.Add(toAddress);
 
            MailMessage msg = new MailMessage(fromAddress, toAddress);
            msg.Subject = Subject;
            msg.Body = Body;
 
            SmtpClient mail = new SmtpClient(Host);
            mail.Credentials = new NetworkCredential("hyhzj@public.hy.js.cn", "
保密，呵呵
"
);
//
此
SMTP
服务器需要身份验证
            mail.Send(msg);
            return ActivityExecutionStatus.Closed;
        }
}
建立工作流，调用自定义
Activity
解决方案中添加一个顺序工作流控制台项目：WorkflowConsoleApplicationSendMail，工具箱中我们能看到
SendMailActivity
，拖到工作流设计对应区域，
注意
SendMail
与
WorkflowConsoleApplicationSendMail
在同一解决项目中，否则请做：工具箱，右键
-
〉添加选项卡
-
〉取名，右键选项
-
〉选择
SendMail
程序集
-
〉确定
：
设置
SendMailActivity
属性：
执行工作流，查看收件箱：
可以重写
ValidateProperties
方法来完成我们的验证。活动的
ValidateProperties
方法是在进行编译时执行的验证方法。验证我们输入属性格式是否是正确。
 
你必须
Remoting
技术，不熟悉参看文档：
Remoting
技术概述
.Doc
这个练习我们实现一个对用户传递来的数据进行判断的业务，用户提交一个费用报告，程序根据费用数值的大小来决定Approve还是Reject。
这个练习中我们将学习用工作流实现业务、将业务发布为远程对象。
 
前面我们的练习，总是有类似如下的代码：
WorkflowRuntime
workflowRuntime = new WorkflowRuntime();
WorkflowInstance
instance = workflowRuntime.CreateWorkflow(……);
instance.Start();
工作流运行时引擎、工作流实例总是在本地建立，这个练习中我们将实现在远程机器上建立工作流运行时引擎、工作流实例，然后发布为一个远程对象，通过远程对象的包装对用户屏蔽业务的实现。
第一步：建立空解决方案：
RemotingWorkflow1
第二步：添加一个类库项目：
ExpenseReportProj
添加类ExpenseReport用来在 Client与Service端交换数据，注意必须标注Serializable属性，因为Remoting要求Client与Service端交换的引用类型数据必须能够序列化。
ExpenseReport.cs
：
namespace
ExpenseReportProj
{
    [Serializable]
    public class ExpenseReport
    {
        public string EmployeeId = "";
        public int Amount = 0;
        public DateTime SubmittedTime;
    }
}
第三步：添加控制台应用程序
RemotingServiceProj
，并设置为启动项目
Program.cs
：
using
System.Runtime.Remoting;
 
namespace
RemotingServiceProj
{
    class Program
    {
        static void Main(string[] args)
        {
            RemotingConfiguration.Configure("serverCfg.xml", false);
 
            Console.WriteLine("Press Enter to terminate...");
            Console.ReadLine();
        }
}
}
 
RemotingService.cs
：
using
ExpenseReportProj;
 
namespace
RemotingServiceProj
{
    public class RemotingService : MarshalByRefObject
    {
        public void SubmitExpenseReport(ExpenseReport report)
        {
            String dispInfo = report.EmployeeId +" " + report.SubmittedTime
                    + " Submit: " + report.Amount;
            if (report.Amount > 1000)
                Console.WriteLine(dispInfo + " Rejected");
            else
                Console.WriteLine(dispInfo + " Approved");
        }
    }
}
 
serverCfg.xml
：注意要复制到输出目录
<?
xml
version
=
"1.0"encoding="utf-8" ?>
<
configuration
>
 <
system.runtime.remoting
>
    <
application
>
      <
service
>
        <
wellknown
mode
=
"SingleCall"type="RemotingServiceProj.RemotingService,
RemotingServiceProj
"              //type:
类全名（含全部名字空间），程序集名
                  
objectUri
=
"RemotingWorkflow1" />               
      </
service
>
      <
channels
>
        <
channel
ref
=
"tcp server"port="1234" />
      </
channels
>
    </
application
>
 </
system.runtime.remoting
>
</
configuration
>
 
第四步：添加一个
Windows
应用程序：
TestApplication
文件：
Form1.cs
设计界面：
代码：
using
System.Runtime.Remoting;
using
ExpenseReportProj;
using
RemotingServiceProj;
 
namespace
TestApplication
{
    public partial class Form1 : Form
    {
        protected RemotingService Service;
       public Form1()
        {
            InitializeComponent();
 
            RemotingConfiguration.Configure("ClientCfg.xml", false);
            Service = (RemotingService)Activator.GetObject(typeof(RemotingService), "tcp://localhost:1234/RemotingWorkflow1");
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            ExpenseReport Report = new ExpenseReport();
            Report.EmployeeId = EmployeeId.Text;
            Report.Amount = Convert.ToInt32(Amount.Text);
            Report.SubmittedTime = DateTime.Now;
            Service.SubmitExpenseReport(Report);
        }
    }
}
ClientCfg.xml
：注意要复制到输出目录
<?
xml
version
=
"1.0"encoding="utf-8" ?>
<
configuration
>
 <
system.runtime.remoting
>
    <
application
>
      <
client
>
        <
wellknown
type
=
"RemotingServiceProj.RemotingService, RemotingService"
url
=
"RemotingWorkflow1" />    //type:
类全名（含全部名字空间），程序集名
      </
client
>
      <
channels
>
        <
channel
ref
=
"tcp client"port="1234" />
      </
channels
>
    </
application
>
 </
system.runtime.remoting
>
</
configuration
>
解决方案资源：
项目引用关系：

TestApplicatio
n
RemotingServiceProj
 
ExpenseReportProj

类图：
运行效果：
我们修改
Form1.cs
代码
Service = (RemotingService)Activator.GetObject(typeof(RemotingService), "tcp://localhost:1234/RemotingWorkflow1");
中的URL到指定的机器，就可以让服务程序与客户程序在不同的机器运行。
小提示：
     调试时Visual studio可以启动多个项目的：运行，启动了“启动项目”，然后在某个你希望启动的项目上右击鼠标，选择“调试”，点“启动新实例”即可。
首先从前面的设计我们可以发现程序的客户端必须引用实现服务的程序集
RemotingServiceProj并使用实现服务的类
RemotingService，服务的任何改动都需要重新编译客户端，实际上客户端仅需要知道一个描述服务的接口。所以我们进行改进：
客户服务器交换数据定义项目
ExpenseReportProj
中
定义服务接口：
文件：
IremotingService.cs
namespace
ExpenseReportProj
{
    public interface IRemotingService
    {
        void SubmitExpenseReport(ExpenseReport report);
    }
}
 
服务器端RemotingServiceProj的RemotingService实现IremotingService接口：
文件：RemotingService.cs
namespace
RemotingServiceProj
{
public
class RemotingService : MarshalByRefObject, IRemotingService
{
   
……
}
}
 
客户端TestApplication
获得服务接口
IRemotingService
：
文件：Form1.cs
namespace
TestApplication
{
    public partial class Form1 : Form
    {
        protected IRemotingService Service;
        public Form1()
        {
            InitializeComponent();
 
            RemotingConfiguration.Configure("ClientCfg.xml", false);
            Service = (IRemotingService)Activator.GetObject(typeof(IRemotingService), "tcp://localhost:1234/RemotingWorkflow1");
        }
 
……
}
}
 
更改客户端配置：
文件：ClientCfg.xml
……
      <
client
>
       <
wellknown
type
=
"ExpenseReportProj.IRemotingService, ExpenseReportProj"url="RemotingWorkflow1" />
</
client
>
……
 
移除TestApplication对RemotingServiceProj的引用，现在我们可以自由改变服务接口的实现而不需要改客户端程序。类图如下：
文件Form1.cs中我们对访问服务器的URL写死在代码中了，我们希望通过配置文件来指定服务器，所以做如下改进：
namespace
TestApplication
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            Service = (IRemotingService)Activator.GetObject(typeof(IRemotingService), "tcp://localhost:1234/RemotingWorkflow1");
        }
……
}
}
 
Form1.cs
做如下改进，注意添加了方法
GetURLFromRemotingClientConfig
：
using
ExpenseReportProj;
using
System.Xml;
 
namespace
TestApplication
{
    public partial class Form1 : Form
    {
        protected IRemotingService Service;
        public Form1()
        {
            InitializeComponent();
 
            String ClientCfgFileName = "ClientCfg.xml";
            RemotingConfiguration.Configure(ClientCfgFileName, false);
            Service = (IRemotingService)Activator.GetObject(typeof(IRemotingService),
                GetURLFromRemotingClientConfig(ClientCfgFileName));
        }
       
……
.
        private String GetURLFromRemotingClientConfig (String ClientCfgFileName)
        {
            string serviceValue = "", refValue = "", portValue = "", urlValue = "";
 
            using (XmlReader clientXml = XmlReader.Create(ClientCfgFileName))
                while (clientXml.Read())
                    for (int i = 0; i < clientXml.AttributeCount; i++)
                    {
                        clientXml.MoveToAttribute(i);
                        switch (clientXml.Name.ToLower())
                        {
                            case "service":
                                serviceValue = clientXml.Value;
                                break;
                            case "ref":
                                refValue = clientXml.Value;
                                break;
                            case "port":
                                portValue = clientXml.Value;
                                break;
                            case "url":
                                urlValue = clientXml.Value;
                                break;
                        }
                    }
 
            if (refValue.ToUpper().IndexOf("TCP") == 0)
                return "tcp://" + serviceValue + ":" + portValue + "/" + urlValue;
            else
                return "";
        }
    }
}
 
更改客户端配置：
文件：ClientCfg.xml
<?
xml
version
=
"1.0"encoding="utf-8" ?>
<
configuration
>
 <
system.runtime.remoting
>
    <
application
>
      <
client
>
        <
wellknown
type
=
"ExpenseReportProj.IRemotingService, ExpenseReportProj"url="RemotingWorkflow1" />
      </
client
>
      <
channels
>
        <
channel
ref
=
"tcp client"service="localhost" port="1234" />
      </
channels
>
    </
application
>
 </
system.runtime.remoting
>
</
configuration
>
 
通过前面两个练习，我们熟悉了Remoting技术，建立了一个结构良好的Remoting应用，后面我们将在此基础上用工作流技术实现这一应用的服务。
在解决方案中添加一个顺序
工作流控制台应用程序：
WorkflowExpenseReportServiceProj
小提示：
我们需要的是一个类库，实际上控制台应用程序、 windows应用程序都可以直接当作类库使用的，我们这儿建立控制台应用程序为了在开发时更方便地进行测试。
添加对
ExpenseReportProj
的引用
删除program.cs
添加类WorkflowExpenseReportService
WorkflowExpenseReportService.cs
：
using
ExpenseReportProj;
 
namespace
WorkflowExpenseReportServiceProj
{
    public class Test
    {
        static void Main(string[] args)
        {
            WorkflowExpenseReportService Service = new WorkflowExpenseReportService();
            ExpenseReport report = new ExpenseReport();
            report.EmployeeId = "
当作控制台程序测试下"
;
            report.SubmittedTime = DateTime.Now;
            report.Amount = 100;
 
           Service.SubmitExpenseReport(report);
           Console.ReadLine();
        }
    }
 
    public class WorkflowExpenseReportService : MarshalByRefObject, IRemotingService
    {
        public void SubmitExpenseReport(ExpenseReport report)
        {
            using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
            {
                AutoResetEvent waitHandle = new AutoResetEvent(false);
                workflowRuntime.WorkflowCompleted += delegate(object sender,
                    WorkflowCompletedEventArgs e) { waitHandle.Set(); };
                workflowRuntime.WorkflowTerminated += delegate(object sender,
                    WorkflowTerminatedEventArgs e)
                {
                    Console.WriteLine(e.Exception.Message);
                    waitHandle.Set();
                };
 
                Dictionary<string, object> parameters = new Dictionary<string, object>();
                parameters.Add("Report", report);
                WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(Workflow1), parameters);
                instance.Start();
 
                waitHandle.WaitOne();
            }
        }
    }
}
说明：
WorkflowExpenseReportService类做为远程服务，必须派生自
MarshalByRefObject,且实现我们本解决方案需要的服务接口IremotingService，在SubmitExpenseReport方法中传递参数report到工作流，如何传递参数前面练习做过。
Main方法中我们使工作流能够直接测试。
设计工作流：
双击Workflow1.cs，打开设计器，从工具箱拖一个code activity到设计器：
选中设计器中的codeActivity1，点属性，为ExecuteCode属性输入此Activity执行的方法名ShowReportInfo,并双击，Visual studio会自动生成对应方法的代码框架：
编辑Workflow1对应的代码，添加属性
public
ExpenseReport Report
，在ShowReportInfo方法中显示属性Report的信息：
文件Workflow1.cs
using
ExpenseReportProj;
 
namespace
WorkflowExpenseReportServiceProj
{
     public sealed partial class Workflow1: SequentialWorkflowActivity
     {
         public Workflow1()
         {
              InitializeComponent();
         }
 
        ExpenseReport _Report;
        public ExpenseReport Report
        {
            get { return _Report; }
            set { _Report = value; }
        }
 
        private void ShowReportInfo(object sender, EventArgs e)
        {
            Console.WriteLine(Report.EmployeeId);
        }
     }
}
运行此工作流控制台程序WorkflowExpenseReportServiceProj，应该看到：
第一步我们完成了建立一个实现
IRemotingService 接口的可以作为Remoting服务的类WorkflowExpenseReportService， 并对它独立地完成了测试。
现在我们把
WorkflowExpenseReportService当作远程服务进行测试：
首先修改RemotingServiceProj的配置文件ServerCfg.xml：
<?
xml
version
=
"1.0"encoding="utf-8" ?>
<
configuration
>
 <
system.runtime.remoting
>
    <
application
>
      <
service
>
        <!--
<wellknown mode="SingleCall" type="RemotingServiceProj.RemotingService, RemotingServiceProj"
                   objectUri="RemotingWorkflow1" />
-->
        <
wellknown
mode
=
"SingleCall"type="WorkflowExpenseReportServiceProj.WorkflowExpenseReportService, WorkflowExpenseReportServiceProj"
                  
objectUri
=
"RemotingWorkflow1" />
      </
service
>
      <
channels
>
        <
channel
ref
=
"tcp server"port="1234" />
      </
channels
>
    </
application
>
 </
system.runtime.remoting
>
</
configuration
>
我们更改了 type属性，定位到我们用工作流实现的服务业务逻辑
WorkflowExpenseReportService 类。
复制程序集WorkflowExpenseReportServiceProj到RemotingServiceProj的bin/Debug目录下，运行RemotingServiceProj，运行TestApplication，测试，我们应该看到：
前面我们已经用工作流完成了远程业务对象，并进行了测试，当然业务逻辑还没有实现，业务逻辑我们可以在可视化设计器中方便地设计了，使用什么类实现远程服务只需要改个配置文件就可以了。
小提示：
调试时我们让 RemotingServiceProj引用WorkflowExpenseReportServiceProj项目，就可以不用手工复制文件了，免得调试时WorkflowExpenseReportServiceProj改了但忘记复制到RemotingServiceProj的bin/debug下。
设计业务逻辑：
修改Workflow1. ShowReportInfo方法：
        private void ShowReportInfo(object sender, EventArgs e)
        {
            String dispInfo = Report.EmployeeId + " " + Report.SubmittedTime
                    + " Submit: " + Report.Amount;
            if (Report.Amount > 1000)
                Console.WriteLine(dispInfo + " Rejected");
            else
                Console.WriteLine(dispInfo + " Approved");
   }
运行RemotingServiceProj，运行TestApplication，测试，我们应该看到：
业务逻辑已经实现。我们换种方法，通过工作流设计器设计业务逻辑：
删除codeActivity1,从工具箱拖一个IfElseActivity到设计器, 选择IfElseActivity，点红色感叹号，选择下拉菜单“Property
‘
Condition
’
is not set
”:
IfElseActivity
实现工作流的条件判断，运行引擎将从左向右依次处理各分支的条件，如果某分支处理结果是true则顺着此分支执行下去，最后一个分支固定是else，不可设置条件；我们可以拖动分支改变左右顺序，用右键菜单增加分支或按delete键删除分支；分支的条件可以是一个返回boolean的方法或一个boolean表达式，通过condition属性设置。
将跳转到属性窗体并定位于condition属性，我们选择Declarative Rule Condition，定义一个规则表达式：
 
点condition前的+（上图红色圈处），展开condition，点ConditionName右侧‘...’（下图箭头所指）：
弹出Select Condition窗体，点‘New
…
’（红色箭头所指），弹出Rule Condition Editor窗体，输入条件表达式：this.Report.Amount > 1000:
 
点‘OK’,回到设计器，我们已经完成了条件判断，下面我们要完成各条件下执行的操作，我们从工具箱拖两个CodeActivity分别放到两个条件分支下：
将两个IfElse分支分别改名为RejectBranch、ElseBranch,对应的两个codeActivity分别改名为RejectActivity、ApproveActivity:
设置RejectActivity、ApproveActivity的ExecuteCode分别为RejectReport、ApproveReport，双击生成代码，编辑并删除过时的方法Show
ReportInfo
：
Workflow1.cs
using
ExpenseReportProj;
 
namespace
WorkflowExpenseReportServiceProj
{
    public sealed partial class Workflow1 : SequentialWorkflowActivity
    {
        public Workflow1()
        {
            InitializeComponent();
        }
 
        ExpenseReport _Report;
 
        public ExpenseReport Report
        {
            get { return _Report; }
            set { _Report = value; }
        }
 
        private void RejectReport(object sender, EventArgs e)
        {
            Console.WriteLine(Report.EmployeeId + " " + Report.SubmittedTime
                    + " Submit: " + Report.Amount + " Rejected");
        }
 
        private void ApproveReport(object sender, EventArgs e)
        {
            Console.WriteLine(Report.EmployeeId + " " + Report.SubmittedTime
                + " Submit: " + Report.Amount + " Approved");
        }
    }
}
保存、编译、运行，我们将看到系统正确地实现了我们的业务逻辑。
我们知道 Workflows需要寄宿在一个进程中，任何的应用或者服务都可以是Workflow的宿主，WF处理空间和Host空间之间的数据交换通过
ExternalDataExchangeService完成。
WF和 Host之间的数据交换通过以
ExternalDataExchangeAttribute修饰的接口定义，这些接口我们称为本地服务。我们在
ExternalDataExchangeService中注册实现这些本地服务的对象。
CallExternalMethodActivity、
HandleExternalEventActivity共同实现与本地服务的双向交流。
一：创建顺序工作流控制台程序CallExternalMethod
以及对应的解决方案。
二：在解决方案中添加
windows
类库
ExternalDataInterface
。
三：让CallExternalMethod
引用
ExternalDataInterface
。
四：定义本地服务以及实现这些本地服务的类，并编译
ExternalDataInterface
：
using
System.Workflow.Activities;
using
System.Windows.Forms;
 
namespace
ExternalDataInterface
{
    [ExternalDataExchange]
    public interface IExternal
    {
        void ExternalMethod();
    }
 
    public class External: IExternal
    {
        public void ExternalMethod()
        {
            System.Windows.Forms.MessageBox.Show("External.ExternalMethod Executive");
        }
    }
}
五：注册本地服务，见下列代码中粗体部分：
using
System.Workflow.Runtime;
using
System.Workflow.Runtime.Hosting;
using
System.Workflow.Activities;
using
ExternalDataInterface;
 
namespace
CallExternalMethod
{
    class Program
    {
        static void Main(string[] args)
        {
            using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())
            {
                AutoResetEvent waitHandle = new AutoResetEvent(false);
 
                ExternalDataExchangeService dataService = new ExternalDataExchangeService();
                workflowRuntime.AddService(dataService);
 
                External external = new External();
                dataService.AddService(external);
               
                workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) {waitHandle.Set();};
                workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
                {
                    Console.WriteLine(e.Exception.Message);
                    waitHandle.Set();
                };
 
                workflowRuntime.CreateWorkflow(typeof(CallExternalMethod.Workflow1)).Start();
                waitHandle.WaitOne();
                Console.WriteLine("Press any key to exit...");
                Console.Read();
            }
        }
    }
}
六：调用本地服务中的方法：
打开CallExternalMethod
的工作流Workflow1
，从工具箱拖一个CallExternalMethod
到设计器：
设置
CallExternalMethodActivity
的属性，点
InterfaceType
右侧省略号，见下图：
会弹出
Browse and Selet a .NET Type
窗体，选择我们定义的本地服务类型，如果没有列出，检查服务是否用
ExternalDataExchangeAttribute
修饰、CallExternalMethod
是否引用
ExternalDataInterface
并编译ExternalDataInterface。
设置要调用的方法名：
运行，我们可以看到
External.ExternalMethod
方法被调用：
注意：
本地服务以
ExternalDataExchangeAttribute修饰的接口定义，其中仅直接说明的方法和事件有效，如果从其它接口派生，即使父接口也是本地服务，父接口中的方法也不能被WF处理空间调用。
每一个本地服务在
ExternalDataExchangeService中仅可以注册一个实现这个本地服务的对象，否则出错。
一：修改
本地服务的方法
ExternalMethod
，添加参数：
using
System.Workflow.Activities;
using
System.Windows.Forms;
 
namespace
ExternalDataInterface
{
    [ExternalDataExchange]
    public interface IExternal
    {
       void ExternalMethod(String Info);
    }
 
    public class External: IExternal
    {
        public void ExternalMethod(String Info)
        {
            System.Windows.Forms.MessageBox.Show("External.ExternalMethod Executive, parameter: " + Info);
        }
    }
}
二：编译
ExternalDataInterface
。
三：
设置
CallExternalMethodActivity
的属性，我们看到多了属性
Info
：
点Info
右侧省略号，弹出Bind ‘Info’ to an activity’s property
窗体，在此我们设置调用
External.ExternalMethod
方法时把
Workflow1
的哪一个成员（属性或字段）做为参数传递给
ExternalMethod
方法的参数
Info
。现有成员中没有合适的，我们点
Bind a new member
页，为
Workflow1
添加一个新的属性
WorkflowInfo
，并传递给
ExternalMethod
方法：
此处我们可以创建Field
或Property
，选择Property
将使我们程序更灵活点。确定，查看Workflow1.cs
的代码，在构造函
数中对
WorkflowInfo
赋值
：
using
System.Workflow.Activities;
using
System.Workflow.Activities.Rules;
 
namespace
CallExternalMethod
{
     public sealed partial class Workflow1: SequentialWorkflowActivity
     {
         public Workflow1()
         {
              InitializeComponent();
              WorkflowInfo = Name + " Initialize: " + DateTime.Now.ToString();
         }
 
        public static DependencyProperty WorkflowInfoProperty = DependencyProperty.Register("WorkflowInfo", typeof(System.String), typeof(CallExternalMethod.Workflow1));
 
        [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
        [BrowsableAttribute(true)]
        [CategoryAttribute("Parameters")]
        public String WorkflowInfo
        {
            get
            {
                return ((string)(base.GetValue(CallExternalMethod.Workflow1.WorkflowInfoProperty)));
            }
            set
            {
                base.SetValue(CallExternalMethod.Workflow1.WorkflowInfoProperty, value);
            }
        }
     }
}
运行，我们可以看到
External.ExternalMethod
方法被调用且工作流的参数被正确传递出：
传递返回值与传递参数非常类似，首先我们
修改
本地服务的方法
ExternalMethod
，添加返回值，编译
：
using
System.Windows.Forms;
 
namespace
ExternalDataInterface
{
    [ExternalDataExchange]
    public interface IExternal
    {
        String ExternalMethod(String Info);
    }
 
    public class External: IExternal
    {
        public String ExternalMethod(String Info)
        {
            System.Windows.Forms.MessageBox.Show("External.ExternalMethod Executive, parameter: " + Info);
            return "ExternalMethod Result";
        }
    }
}
设计工作流，我们看到
CallExternalMethodActivity
属性多了
ReturnValue
，把它绑定到
Workflow1
的新属性
ExternalMethodResult
（如何做见传递参数部分）
.
添加CodeActivity
用来显示
ExternalMethodResult:
设置codeActivity1
的ExecuteCode
为ShowExternalMethodResult
，双击，编写代码：
using
System.Workflow.Activities.Rules;
 
namespace
CallExternalMethod
{
     public sealed partial class Workflow1: SequentialWorkflowActivity
     {
……
        private void ShowExternalMethodResult(object sender, EventArgs e)
        {
            Console.WriteLine(ExternalMethodResult);
        }
     }
}
运行，我们看到返回值已经正确接收到：
外部事件是工作流的驱动力，任何实际的工作流都是靠外部事件驱动它一步步完成业务的。Windows workflow的外部事件是我们学习的关键，同时也是比较复杂的，为更牢固地掌握外部事件，这一小节我们用不断尝试错误的方法进行学习，也许过于繁琐，因为我实在想不出合适的方法和例子来讲解，哭。
感觉这个练习设计的有很大的问题。
一：建立顺序工作流控制台项目以及对应解决方案
ListenExternalEvent
，添加windows 雷库项目 LocalServicesProj，让ListenExternalEvent引用LocalServicesProj。
二：LocalServicesProj添加引用：
三：在
LocalServicesProj
项目中定义本地服务接口IlocalServices以及实现此接口的对象localServices：
IlocalServices.cs:
using
System;
using
System.Collections.Generic;
using
System.Text;
using
System.Workflow.Activities;
 
namespace
LocalServicesProj
{
    public delegate void dlgExternalEvent();
 
    [ExternalDataExchange]
    public interface ILocalServices
    {
        event dlgExternalEvent ExternalEvent;
    }
 
    public class LocalServices : ILocalServices
    {
        public event dlgExternalEvent ExternalEvent;
 
        public void TriggerExternalEvent()
        {
            ExternalEvent();
        }
    }
}
四：
Workflow1
添加一个处理外部事件的
HandleExternalEventActivity:
五：设置
HandleExternalEventActivity1
的属性，首先需要设置
InterfaceType
，点省略号，选择，见下图：
如果没列出LocalServicesProj，检查ListenExternalEvent是否引用了 LocalServicesProj并编译LocalServicesProj。
如果LocalServicesProj中没有ILocalServices，检查IlocalServices是否用ExternalDataExchangeAttribute修饰
六：设置
HandleExternalEventActivity1
的
EventName:
七：在
program.cs
注册本地服务：
using
System.Threading;
using
System.Workflow.Runtime;
using
System.Workflow.Runtime.Hosting;
using
System.Workflow.Activities;
using
LocalServicesProj;
 
namespace
ListenExternalEvent
{
    class Program
    {
        static void Main(string[] args)
        {
            using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())
            {
                AutoResetEvent waitHandle = new AutoResetEvent(false);
 
                ExternalDataExchangeService dataService = new ExternalDataExchangeService();
                workflowRuntime.AddService(dataService);
 
                LocalServices localServices = new LocalServices();
                dataService.AddService(localServices);
 
 
                workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { waitHandle.Set(); };
                workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
                {
                    Console.WriteLine(e.Exception.Message);
                    waitHandle.Set();
                };
 
                WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(ListenExternalEvent.Workflow1));
                instance.Start();
 
                waitHandle.WaitOne();
            }
        }
    }
}
八：编译解决方案，得到错误：
原来工作流中HandleExternalEventActivity要求的事件必须是一个用ExternalDataEventArgs实例化的EventHandler范型方法，我们根据提示修改
IlocalServices.cs
中的
IlocalServices
以及
LocalServices:
namespace
LocalServicesProj
{
    //public delegate void dlgExternalEvent();
 
    [ExternalDataExchange]
    public interface ILocalServices
    {
        event EventHandler<ExternalDataEventArgs> ExternalEvent;
    }
 
    public class LocalServices : ILocalServices
    {
        public event EventHandler<ExternalDataEventArgs> ExternalEvent;
 
        public void TriggerExternalEvent()
        {
            ExternalEvent(null, null);
        }
    }
}
九：可以通过编译，运行，程序什么也没做，暂停，我们看到程序停在waitHandle.WaitOne()上：
十：添加两个CodeActivity,分别取名WorkflowStart、WorkflowEnd，设置它们的ExecuteCode属性，分别执行方法WriteStartInfo、WriteEndInfo，Program.cs适当修改，这样我们就可以从控制台上看到工作流的开始、结束了：
Workflow1.cs:
namespace
ListenExternalEvent
{
     public sealed partial class Workflow1: SequentialWorkflowActivity
     {
         public Workflow1()
         {
              InitializeComponent();
         }
 
        private void WriteStartInfo(object sender, EventArgs e)
        {
            Console.WriteLine(this.WorkflowInstanceId.ToString() + " Start");
        }
 
        private void WriteEndInfo(object sender, EventArgs e)
        {
            Console.WriteLine(this.WorkflowInstanceId.ToString() + " End");
        }
     }
}
 
Program.cs:
namespace
ListenExternalEvent
{
    class Program
    {
        static void Main(string[] args)
        {
            using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())
            {
……
                waitHandle.WaitOne();
           
                System.Console.WriteLine("Hit <enter> to exit...");
                System.Console.ReadLine();
            }
        }
    }
}
十一：运行，我们看到程序停在waitHandle.WaitOne()上
前面我们建立了一个顺序工作流，这一部分我们试图使其响应事件。
一：在program.cs
添加如下行触发事件：
Program.cs:
……
                WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(ListenExternalEvent.Workflow1));
                instance.Start();
 
                localServices.TriggerExternalEvent();
 
                waitHandle.WaitOne();
           
                System.Console.WriteLine("Hit <enter> to exit...");
                System.Console.ReadLine();
            }
        }
    }
}
二：运行，异常，查看：
三：
报的错误是ArgumentNullException，查帮助：
ArgumentNullException
的引发条件为：调用某种方法时所传递的参数中，至少有一个在任何情况下都不应为空引用（在
Visual Basic
中为
Nothing
）
的参数为空引用（在
Visual Basic
中为
Nothing
）。
我们中断程序，调试，发现ExternalEvent事件居然有值了，我们从没为它添加事件响应方法！异常是因为在调用这一事件响应函数时参数为 null值而抛出的。我们对LocalServices做小改动，验证下：
可以发现，ExternalEvent2为 null, 而ExternalEvent是有值的，它们间的差别就在Workflow1试图响应ExternalEvent事件，ExternalEvent在什么地方被添加了事件响应函数呢？显然与program.cs的下列代码有关，ExternalDataExchangeService为ExternalEvent事件赋值了：
                ExternalDataExchangeService dataService = new ExternalDataExchangeService();
                workflowRuntime.AddService(dataService);
 
                LocalServices localServices = new LocalServices();
                dataService.AddService(localServices);
前面抛出的异常显然是因为我们触发事件的代码提供了两个null值：ExternalEvent(
null, null)
;
我们修改代码，提供参数：
    public class LocalServices : ILocalServices
    {
        public event EventHandler<ExternalDataEventArgs> ExternalEvent;
 
        public void TriggerExternalEvent()
        {
            ExternalEvent(null, new ExternalDataEventArgs());
        }
    }
ExternalDataEventArgs有三个构造函数，但它们都需要一个参数 Guid instanceId ,我们可用想到：我们在ExternalDataExchangeService中注册本地服务时，没有指定Workflow类型与实例，由ExternalDataExchangeService根据接口自动处理，当我们在本地服务触发一个事件时由那个工作流实例响应呢？显然参数Guid instanceId具有决定性作用， ExternalDataExchangeService提供了单一的事件响应函数，然后根据instanceId决定将事件传递给哪一个工作流实例。这也解释了为什么本地服务的事件必须是一个用ExternalDataEventArgs实例化的EventHandler范型方法。
四：我们修改事件触发代码，从外部接收一个instanceId参数，并且让用户决定什么时刻实际触发事件：
    public class LocalServices : ILocalServices
    {
        public event EventHandler<ExternalDataEventArgs> ExternalEvent;
 
        public void TriggerExternalEvent(Guid InstanceID)
        {
            MessageBox.Show("
点确定将触发ExternalEvent事件"
);
            ExternalEvent(null, new ExternalDataEventArgs(InstanceID));
        }
    }
五：修改
program.cs
的
main
方法，传递参数：
    class Program
    {
        static void Main(string[] args)
        {
            using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())
            {
……
                WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(ListenExternalEvent.Workflow1));
                instance.Start();
 
                localServices.TriggerExternalEvent(instance.InstanceId);
                waitHandle.WaitOne();
           
                System.Console.WriteLine("Hit <enter> to exit...");
                System.Console.ReadLine();
            }
        }
六：运行：
我们点“确定”：
触发事件时
ExternalEvent
的Sender参数为什么必须是null？其它值会出现
异常：
前面的练习我们看到外部事件是一个标准EventHandler，显然参数和返回值通过TEventArgs e 传递，我们看下ExternalDataEventArgs，不适合传递其它参数，所以我们需要创建派生于 ExternalDataEventArgs的类型用来传递参数，
事件需要ExternalDataEventArgs，触发事件传递ExternalDataEventArgs的派生类的实例是可以的。
一：我们修改LocalServicesProj.cs的代码：
namespace
LocalServicesProj
{
    public class exerciseExternalDataEventArgs: ExternalDataEventArgs
    {
        public exerciseExternalDataEventArgs(Guid instanceId)
            : base(instanceId)
        {
        }
        public DateTime triggerTime, respondTime;
    }
 
    [ExternalDataExchange]
    public interface ILocalServices
    {
        event EventHandler<ExternalDataEventArgs> ExternalEvent;
    }
 
    public class LocalServices : ILocalServices
    {
        public event EventHandler<ExternalDataEventArgs> ExternalEvent;
 
        public void TriggerExternalEvent(Guid InstanceID)
        {
            exerciseExternalDataEventArgs eventArgs = new exerciseExternalDataEventArgs(InstanceID);
            MessageBox.Show("
点确定将触发ExternalEvent事件"
);
            eventArgs.triggerTime = DateTime.Now;
            ExternalEvent(null, eventArgs);
            Console.WriteLine("LocalServices WriteLine: respondTime: " + eventArgs.respondTime);
        }
    }
}
 
我们用 exerciseExternalDataEventArgs的属性triggerTime和respondTime传入传出参数。
二：编译运行，出错！
三：这个错误是因为触发事件传递的参数
e
必须能够被序列化，而我们定义的
exerciseExternalDataEventArgs
没有用
Serializable
修饰，为什么必须这么做，原因我还没搞清楚。修改
exerciseExternalDataEventArgs
：
    [Serializable]
    public class exerciseExternalDataEventArgs : ExternalDataEventArgs
    {
        public exerciseExternalDataEventArgs(Guid instanceId)
            : base(instanceId)
        {
        }
 
        public DateTime triggerTime, respondTime;
    }
四：运行，可以了。现在我们在工作流中接收数据并返回值：
我们看到有参数
sender
和
e
，我们可以把它们绑定到工作流的属性或字段，操作见前面的调用外部方法。
我们还看到有
Invoked
属性，也就是说
HandleExternalEventActivity
在事件发后可以直接调用一个方法，这是非常方便的，不必要将参数绑定到字段，再加个
CodeActivity
处理了，我们设置
Invoked
属性
handleEvent
，双击编写代码：
     public sealed partial class Workflow1: SequentialWorkflowActivity
     {
……
        private void handleEvent(object sender, ExternalDataEventArgs e)
        {
            Console.WriteLine("Workflow1 WriteLine: triggerTime" + (e as exerciseExternalDataEventArgs).triggerTime);
            Thread.Sleep(2000);
            (e as exerciseExternalDataEventArgs).respondTime = DateTime.Now;
        }
     }
五：运行：
明显值传递进了工作流，但我们的
host
触发事件后自己在继续跑，见
”LocalServices WriteLine”
在
”Workflow1 WriteLine”
前面，这是一个非常重要的概念，事件是异步的
-
工作流实例和
host
程序是异步的
。所以我们想得到返回值还得用其它方法，如
HandleExternalEventActivity
后面加个CallExternalMethod
等。
    <ProjectTypeGuids>{14822709-B5A1-4724-98CA-57A101D1B079};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 
在这一练习中我们完成一个费用审批业务，这是一个比较全面的练习，对基础的技术与操作不再详细描述，你必须完成前面的练习。
这一练习模仿Hands-On Lab 1-3/ Hands-On Lab 1-4。
这一练习我们还是采用逐步完善的策略，迭代完成。
业务描述：用户提交费用报告，如果费用少于某值，此报告自动通过，否则由管理者决定是否通过此费用报告。
已完成代码见：MyExpenseWorkflows_1
目录
建立项目与解决方案：
l
        
解决方案：MyExpenseWorkflows
l
        
Windows
窗体应用程序：ExpenseClientApplication
，是客户端程序，与用户交互，处理费用报告的提交、查看
l
        
控制台应用程序：ExpenseHost
，远程服务的Host程序
l
        
类库项目：ExpenseServices
，远程服务的服务实现以及与实现业务的工作流交换数据的本地服务实现
l
        
类库项目：ExpenseRemoteInterface
，定义客户端与服务端的服务接口
l
        
类库项目：ExpenseReportType
， 费用报告数据对象定义
l
        
类库项目：ExpenseLocalServiceInterface
，定义远程服务与工作流的数据交换的本地服务接口
l
        
工作流库项目：MyExpenseWorkflows
，实现业务逻辑的工作流
项目间关系：
建立所有接口、类、窗体以及配置文件，删除无意义文件，解决方案结构如上图。
注意配置文件的复制到输出目录。
在解决方案目录下建立子目录：Bin
，设置所有项目的输出目录为../BIN
提示：
visual studio项目如果输出目录是项目主目录的子，则项目重新生成时，会删除输出目录下所有内容。这回导致项目A输出到项目B的输出目录，且项目A先于项目B编译，项目B编译时会删除项目A的输出，这算是一个功能BUG。所以我们通常在解决方案下建立公共的输出目录。
做基本测试：
定义远程服务接口IExpenseRemotingService.cs
：
namespace
ExpenseRemoteInterface
{
    public interface IExpenseRemotingService
    {
        void Test(String S);
    }
}
实现远程服务接口ExpenseRemoteService.cs：
namespace
ExpenseServices
{
    public class ExpenseRemoteService : MarshalByRefObject, IExpenseRemotingService
     {
        public void Test(String S)
        {
            Console.WriteLine("ExpenseRemoteService.Test: " + S);
        }
    }
}
调用远程服务Form1.cs：
namespace
ExpenseClientApplication
{
   public partial class Form1 : Form
    {
        protected IExpenseRemotingService Service;
        public Form1()
        {
            InitializeComponent();
 
            String ClientConfigFileName = "ExpenseClient.Cfg.xml";
            String Url = RemotingClientConfig.GetURLFromRemotingClientConfig(ClientConfigFileName);
 
            RemotingConfiguration.Configure(ClientConfigFileName, false);
            Service = (IExpenseRemotingService)Activator.GetObject(typeof(IExpenseRemotingService), Url);
       }
 
        private void button1_Click(object sender, EventArgs e)
        {
            Service.Test("dddddddddddd");
        }
    }
}
以下文件参看已完成的代码，文档中不列出：
l
         RemotingClientConfig.cs：通过客户端配置获得服务器URL。
l
         ExpenseClient.Cfg.xml：客户端远程服务访问参数配置，注意客户端
<client><wellknown>小节配置完整的URL后，
<channels>小节可以省略。
l
         ExpenseService.Cfg.xml：服务端服务发布参数配置。
设置
ExpenseServices
的启动操作：
配置解决方案启动项目如下（点解决方案，右键，属性）：
执行，你应该看到远程方法被正确调用：
已完成代码见：MyExpenseWorkflows_2
目录
一：定义
IExpenseRemotingService
    public interface IExpenseRemotingService
    {
        void SubmitExpenseReport(ExpenseReport expenseReport);
 
        List<ExpenseReport> GetExpenseReportsList();
    }
二：设计客户端
操作不再详述，参看已经完成的文档
三：设计工作流
ExpenseWorkflow
，准备接收参数
Report
并在控制台上输出信息表达工作流开始
     public partial class ExpenseWorkflow : SequentialWorkflowActivity
     {
        private void ShowStartInfo(object sender, EventArgs e)
        {
            Console.WriteLine("ExpenseWorkflow(" + WorkflowInstanceId + ") Start");
        }
 
        private ExpenseReport report;
 
        public ExpenseReport Report
        {
            get { return report; }
            set { report = value; }
        }
    
    }
 
四：实现远程服务
    public class ExpenseRemoteService : MarshalByRefObject, IExpenseRemotingService
     {
        public ExpenseRemoteService()
        {
            //
代码段1
            //Console.WriteLine("new ExpenseRemoteService!");
 
            StartWorkflowHost();
        }
 
        WorkflowRuntime workflowRuntime;
        ExpenseLocalService LocalService;
        List<ExpenseReport> ReportsList = new List<ExpenseReport>();
        Dictionary<Guid, Guid> InstanceList = new Dictionary<Guid, Guid>();
 
        private void StartWorkflowHost()
        {
            workflowRuntime = new WorkflowRuntime();
            workflowRuntime.StartRuntime();
 
            AutoResetEvent waitHandle = new AutoResetEvent(false);
            workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e)
           
　　{ waitHandle.Set(); };
            workflowRuntime.WorkflowTerminated += delegate(object sender,WorkflowTerminatedEventArgs e)
            {
                Console.WriteLine(e.Exception.Message);
                waitHandle.Set();
            };
 
            ExternalDataExchangeService exSvc = new ExternalDataExchangeService();
           workflowRuntime.AddService(exSvc);
            LocalService = new ExpenseLocalService();
            exSvc.AddService(LocalService);
        }
 
        public void SubmitExpenseReport(ExpenseReport expenseReport)
        {
            //
代码段2
            //Assembly assm = Assembly.Load("MyExpenseWorkflows");
            //Type typeExpenseWorkflow = assm.GetType("MyExpenseWorkflows.ExpenseWorkflow");
 
            Dictionary<string, Object> parameters = new Dictionary<string, Object>();
            parameters.Add("Report", expenseReport);
 
            //
代码段3
            //WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeExpenseWorkflow, parameters);
            WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(ExpenseWorkflow), parameters);
            ReportsList.Add(expenseReport);
            InstanceList.Add(expenseReport.ExpenseReportId, instance.InstanceId);
 
            instance.Start();
        }
 
        public List<ExpenseReportType.ExpenseReport> GetExpenseReportsList()
        {
            return ReportsList;
        }
}
五：运行程序
我们发现问题：工作流的确启动了，但点“Refresh Reports”，表格没有数据！
在ExpenseRemoteService的如下位置设置断点调试：
我们发现在方法SubmitExpenseReport中确实将expenseReport加入了ReportList，但在方法GetExpenseReportsList中ReportList总是空，而我们任何位置都没有删除过ReportList中的对象，我们有足够的理由猜到GetExpenseReportsList中ReportList已经不是SubmitExpenseReport中的ReportList了，在StartWorkflowHost方法添加代码“
//
代码段1”，调试：
我们发现每次调用远程对象的方法都回新建一个ExpenseRemoteService，根据我们的Remoting知识，我们需要改ExpenseService.Cfg.xml文件，使ExpenseRemoteService由服务器端激活：
      
一个
single-call
服务器端激活对象只在方法调用期间生存。之后，被垃圾回收器标记为删除。
Singleton
服务器激活对象和客户端激活对象不一样，他们的生存期被租用控制。租用是一个对象，它实现了定义在
System.Runtime.Remoting.Lifetime
名称空间的
Ilease
接口。
      Singleton
服务器端激活对象和客户端激活对象缺省的租用对象有一个
5
分钟的
InitialLeaseTime
，
2
分钟的
RenewOnCallTime
，
5
分钟的
CurrentLeaseTime
。如果对象没有方法被调用，当
CurrentLeaseTime
为
0
时它被清除，也就是
5
分钟后被清除。
<?
xml
version
=
"1.0"encoding="utf-8" ?>
<
configuration
>
 <
system.runtime.remoting
>
    <
application
>
      <
service
>
        <
wellknown
mode
=
"Singleton"
         
type
=
"ExpenseServices.ExpenseRemoteService, ExpenseServices"
         
objectUri
=
"ExpenseRemoteService" />
      </
service
>
      <
channels
>
        <
channel
ref
=
"tcp server"port="8342" />
      </
channels
>
    </
application
>
 </
system.runtime.remoting
>
</
configuration
>
再次运行程序，可以看到ExpenseRemoteService只激活一次，GetExpenseReportsList也能正确返回结果了。
这是一个练习，我们没有持久化数据，只是在ExpenseRemoteService对象中保存我们的数据。实际系统中当然不能这样处理。
六：对程序做小的优化：
我们加入代码段2，3，注释掉代码段3下的行：
WorkflowInstance
instance = workflowRuntime.CreateWorkflow(typeof(ExpenseWorkflow), parameters);
移除项目 ExpenseServices对MyExpenseWorkflows的引用，我们在动态地装载实现业务的工作流，如果装载来源我们从配置文件得到，我们就能实现ExpenseRemoteService通过配置文件决定用哪一个具体工作流实现它所需要的业务了，ExpenseRemoteService会提供一个IexpenseLocalService以及参数
Report。
状态改变后自动更新客户端
我们的程序每次提交费用报告后必须手工刷新才能看到服务器端数据的变化，我们可以通过Remoting远程事件使服务器端Report改变后自动触发客户端事件更新客户端界面。
这个过程比较复杂，且Remoting远程事件不是本文档的主要内容，因此我们完成了此功能，放在MyExpenseWorkflows_3下，在此不再讲述相关技术以及操作过程了。你可以参照完成的例子以及文档“Remoting技术概述.Doc”自行学习。
为避免繁杂的内容干扰我们的学习，后面的例子我们仍然从MyExpenseWorkflows_2改进和发展。
已完成代码见：MyExpenseWorkflows_4
目录
删除CodeActivity1
，添加一个IfElseActivity
，两个CodeActivity
，并取合适名称，设计工作流如下：
设置AutoApproveBranch
条件如下：
设置两个CodeActivity
的ExecuteCode
：
     public partial class ExpenseWorkflow : SequentialWorkflowActivity
     {
……
        private void Approve(object sender, EventArgs e)
        {
            report.Status = StatusEnum.Approved;
            Console.WriteLine("Report " + report.ExpenseReportId
                + " Amount: " + report.Amount + " Approved");
        }
 
        private void Reject(object sender, EventArgs e)
       {
            report.Status = StatusEnum.Rejected;
            Console.WriteLine("Report " + report.ExpenseReportId
                + " Amount: " + report.Amount + " Rejected");
        }
    
    }
删除不再使用的方法，运行：
我们看到自动审批业务已经完成
深入知识
的复用
与数据库
与Web Service
的可再发行设计工具
宿主程序
流程演练
Windows Workflow是比较新的技术，我也是边学习边写，有太多不妥之处，希望能得到你的帮助。
代码练习用，质量比较差，别笑话哈。
微软的workflow Hands on Labs有十组练习，建议你将其全部做一遍，微软的练习只讲怎么做，不说为什么这么做，且技术跳跃比较大，所以你先学习本文档后再做微软的那组练习会有更大收获。
所以需要下载的virsul studio插件、.Net 3.0、SDK等都在：
//10.10.40.16/
公司内部培训资料
/workflow
如果还有问题联系我：衡正军 jsnjjnhzj@hotmail.com
基于新闻组和论坛的技术支持社区：
 
 
 
  

转载地址：https://blog.csdn.net/glumtree/article/details/1787929 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！

上一篇：Serializable 的作用？
下一篇：Workflow instance 保存机制

发表评论

最新留言

留言是一种美德,欢迎回访！
[***.207.175.100]2024年04月01日 06时02分55秒

关于作者

    喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！
-- 愿君每日到此一游！

推荐文章

用SAP Spartacus 一个实际例子理解Angular ＜ng-template＞的用法和工作原理 2019-04-27
SAP电商云CCV2 Restful API enablement 2019-04-27
Angular里使用createEmbeddedView动态加入新的模板元素 2019-04-27
Angular里使用createEmbeddedView的单步调试 2019-04-27
SAP Spartacus里cx-carousel的实现 2019-04-27
SAP Spartacus里Product Carousel componentData取数据的逻辑研究 2019-04-27
SAP Spartacus ProductService.get的几个调用场景 2019-04-27
Angular单元测试如何只执行指定的测试用例，提高测试速度 2019-04-27
Angular单元测试的一个错误消息 2019-04-27
SAP Spartacus HttpParamsURIEncoder单元测试文件备份 2019-04-27
SAP Spartacus core模块的单元测试 2019-04-27
Angular开发遇到的一个错误消息 - Expected linebreak to be LF(和本地文件的换行设置有关) 2019-04-27
SAP Spartacus里的concurrently依赖 2019-04-27
我的工作日志 - 2020年9月28日 星期一 阴 2019-04-27
演讲预告：一个月的住院经历，我悟到了哪些和程序员职场发展相关的心得 2019-04-27
Angular karma test.ts里一些标准api用console.log打印出的输出 2019-04-27
SAP Spartacus里的产品主数据显示的数据源 2019-04-27
一个实用的显示Visual Studio Code文件绝对路径的扩展应用 2019-04-27
SAP电商云简介 2019-04-27
SAP Spartacus单元测试里Component实例的创建细节 2019-04-27
白红宇的个人博客 - 记录点点滴滴的事 - 您是第 307568160 位访客
访问时间: 2024-04-24 17:05:19 访问IP: 13.59.82.167     Copyright © 2020 - 2023 blog.css8.cn 京ICP备2021015314号-1 手机版