投稿
  1. 简单一点首页
  2. 编程

WorkflowCore 编写与设计

小蓝 • • 编程

一、workflowcore请假

WorkflowCore 作为一个基于 .NET Core 平台上的分布式流程处理框架，不仅支持 SQL Server 执行流程，还可以将内存数据持久化至 Redis、RabbitMQ、MongoDB 等第三方数据存储中心。它能够方便地为请假申请等一些列企业级业务提供处理方案。

下面是一个例子，展示了一个请假过程的 WorkflowCore 代码片段：

public class LeaveWorkflow : IWorkflow
{
    public string Id => "leave";

    public int Version => 1;

    public void Build(IWorkflowBuilder builder)
    {
        builder
            .StartWith(context => ExecutionResult.Next())
            .While(data => ((LeaveData)data).IsNeedLeave, whileBuilder =>
            {
                whileBuilder
                    .Do(then => then.StartWith()
                                     .Output(data => ((LeaveData)data).ApprovalResult, step => step.Result)
                                     .Then("IsLeaveApproved",
                                           conditionBuilder => conditionBuilder
                                                                     .When(data => ((LeaveData)data).ApprovalResult, true)
                                                                     .Then("Approved",
                                                                           thenBuilder => thenBuilder
                                                                                                     .Do(context => Console.WriteLine("Approved successfully."))
                                                                           )
                                                                     .When(data => !((LeaveData)data).ApprovalResult, true)
                                                                     .Then("Rejected",
                                                                           thenBuilder => thenBuilder
                                                                                                     .Do(context => Console.WriteLine("Rejected request."))
                                                                                 ));

            });
    }
}

public class ApplyLeave : StepBody
{
    public bool NeedLeave { get; set; }

    public DateTime StartTime { get; set; }

    public int DurationInDays { get; set; }

    public override ExecutionResult Run(IStepExecutionContext context)
    {
        Console.WriteLine("Applying leave...");
        var approvalResult = new Random().Next(1, 11) > 5;
        return ExecutionResult.Next(new LeaveData
        {
            IsNeedLeave = NeedLeave,
            StartTime = StartTime,
            DurationInDays = DurationInDays,
            ApprovalResult = approvalResult
        });
    }
}

public class LeaveData
{
    public bool IsNeedLeave { get; set; } = true;

    public DateTime StartTime { get; set; } = DateTime.Now;

    public int DurationInDays { get; set; } = 2;

    public bool ApprovalResult { get; set; }
}

二、workflowcore 书籍
为了更好地掌握 WorkflowCore 框架，需要一本详细的书籍来指导我们学习它的使用方法。《Pro WorkflowCore》 是 John Resig、 Jeremy Ashkenas 和 Micha? Chodkowski-Janusz 编写的一本流程自动化开发指南。
笔者在阅读此书时，印象深刻之处在于其对实际业务场景的概述和分析，为我们理解 WorkflowCore 框架提供了了很好的指引。
三、workflowcore流程设计器
WorkflowCore 流程设计器为使用者提供了一种非常方便的方案，使流程的设计变得非常直观。开发者可以利用工具手动绘制流程图，或者自动生成流程步骤列表。
示例代码片段如下：
var steps = new List();
steps.Add(nameof(FindDog));

var descriptor = new WorkflowDefinition()
    .StartWith()
    .Then(
        nameof(FindDog),
        data => data.DogToFind,
        step => step
            .Input(step => step.DogName, data => data.DogToFind)
            .Output(data => data.DogLocation, step => step.Result)
    )
    .Then(
        data => data.NotifyContact,
        step => step.Input(step => step.DogLocation, data => data.DogLocation)
    )
    .If(data => data.HasGivenUp,
        ifBuilder => ifBuilder
            .Do(then => then.StartWith())
            .Then(end => end
                .StartWith(
                    data => data.NotifyContact,
                    step => step.Input(step => step.Message, data => "Lost dog mode has been entered.")
                )
            ))
    .Then(a => a.StartWith());

var xml = new XmlWorkflowSerializer().Serialize(descriptor);

四、workflowcore设计
WorkflowCore 的开发过程相对比较简单，它是开源框架，可以支持你快速编写自己的业务代码来实现各种流程形式。
为了制作自己的 WorkflowCore 进程，你可以从创建一个 Workflow 项目写起：
    

  1. 安装WorkflowCore Nuget 包。
    2. 

  2. 在项目根目录下添加一个与 Workflow 名称一致的类，实现 IWorkflow 接口。
    3. 

  3. 在 Workflow 类中使用 Workflow Builder 对象构建流程（起点和一系列步骤）。
    4. 

  4. 在 Startup.ConfigureServices 方法中使用 WorkflowCore 并行添加 Workflow 服务。
下面是一个最简化的 WorkflowCore 样本代码 :
public class SampleWorkflow : IWorkflow
{
    public string Id => "SampleWorkflow";

    public int Version => 1;

    public void Build(IWorkflowBuilder builder)
    {
        builder
            .StartWith(SayHello)
            .Then(DisplayMessage)
            .Then(End);
    }

    public void End(IStepExecutionContext context)
    {
        Console.WriteLine("Ending workflow...");
    }

    public ExecutionResult SayHello(IStepExecutionContext context)
    {
        Console.WriteLine("Hello World!");
        return ExecutionResult.Next();
    }

    public ExecutionResult DisplayMessage(IStepExecutionContext context)
    {
        Console.WriteLine(context.Workflow.Data.Message);
        return ExecutionResult.Next();
    }
}

public class MyDataClass
{
    public string Message { get; set; }
}

五、workflowcore 执行过程较长时间
WorkflowCore 的执行时间是相对较长的，主要是因为 Workflow 必须通过多个微服务来执行，在这个过程中，可能需要将数据存储到数据库中，与第三方系统交互，并启动其他服务。
因此，在使用 WorkflowCore 时，要注意对任务进行分割和异步处理。
六、workflowcore 设计器
WorkflowCore 的设计器使得开发人员能够在可视化的界面中更方便地 mockup 流程。这个设计器还支持添加一系列的步骤，包括 if/else 语句，分支和循环。
下面是一个 WorkflowCore 设计器的示例代码：
  var design = new WorkflowDesign
  {
    Inputs = new[]
    {
        new WorkflowInput
        {
            Key = "intputOne",
            Label = "Input Number One",
            Type = VariableType.Number
        }
    },
    Steps = new[]
    {
        new WorkflowStep
        {
            Id = "stepOne",
            Label = "Add Two",
            Inputs = new []
            {
                new WorkflowInputMapping
                {
                    SourceKey = "inputOne",
                    DestinationKey = "intOne"
                },
                new WorkflowInputMapping
                {
                    SourceKey = "stepTwoResult",
                    DestinationKey = "intTwo"
                }
            },
            Outputs = new []
            {
                new WorkflowOutputMapping
                {
                    SourceKey = "result",
                    DestinationKey = "stepOneResult"
                }
            },
            Settings = new WorkflowStepSettings
            {
                Type = "SampleType"
            }
        },
        new WorkflowStep
        {
            Id = "stepTwo",
            Label = "Increment",
            Outputs = new []
            {
                new WorkflowOutputMapping
                {
                    SourceKey = "result",
                    DestinationKey = "stepTwoResult"
                }
            }
        }
    }
};

七、workflowcore实战
WorkflowCore 可以被用于各种负载流程，包括需求审批流程、订单和应用程序服务管理流程、甚至是调度生产设备的自动化流程等。
以下即是一个现实与实践密切相关的 WorkflowCore 示例代码：
public class SampleWorkflow : IWorkflow
{
    public string Id => "SampleWorkflow";

    public int Version => 1;

    public void Build(IWorkflowBuilder builder)
    {
        builder
            .StartWith()
                .Output(data => data.Value1, step => step.Value1)
                .Output(data => data.Value2, step => step.Value2)
            .Then()
                .Input(step => step.Value1, data => data.Value1)
                .Input(step => step.Value2, data => data.Value2)
                .Output(data => data.Result, step => step.Result)
            .Then()
                .Input(step => step.Response, data => data.Result);
    }
}

public class MyDataClass
{
    public int Value1 { get; set; }

    public int Value2 { get; set; }

    public int Result { get; set; }
}

public class ReadData : StepBody
{
    public int Value1 { get; set; }

    public int Value2 { get; set; }

    public override ExecutionResult Run(IStepExecutionContext context)
    {
        Value1 = 2;
        Value2 = 5;
        return ExecutionResult.Next();
    }
}

public class CalculateSum : StepBody
{
    public int Value1 { get; set; }

    public int Value2 { get; set; }

    public int Result { get; set; }

    public override ExecutionResult Run(IStepExecutionContext context)
    {
        Result = Value1 + Value2;
        return ExecutionResult.Next();
    }
}

public class SendData : StepBody
{
    public int Response { get; set; }

    public override ExecutionResult Run(IStepExecutionContext context)
    {
        Console.WriteLine($"The result is: {Response}");
        return ExecutionResult.Next();
    }
}

八、workflowcore 图形化
WorkflowCore 支持图形化工具，可以将流程设计转化为一个流程定义 XML 文件。图形化工具使得我们能够更快地创建和修改我们的流程，同时也方便团队协作与沟通，并检测流程的正确性。
下面是一个 WorkflowCore 图形化工具设计的代码：
var def = new ProcessDefinition
{
    Id = "MyFirstWF",
    Steps = new List
    {
        new ProcessStep
        {
            Id = "step1",
            Name = "My First Step",  
            Type = StepType.Task,
            Data = new Dictionary
            {
                {"TaskName", "My Task"}
            }
        },
        new ProcessStep
        {
            Id = "step2",
            Name = "My Second Step",
            Type = StepType.Control,
            Descendants = new List
            {
                "step3"
            },
            Data = new Dictionary
            {
                {"ControlFlowType", ControlFlowType.FullCondition}
            }
        },
        new ProcessStep
        {
            Id = "step3",
            Name = "My Third Step",
            Type = StepType.Task,
            Data = new Dictionary
            {
                {"TaskName", "My Task 2"}
            }
        }
    }
};

var design = WorkflowDesignerParser.Parse(def);

九、workflowcore多人审批
WorkflowCore 可以用于多人审批流程，这个过程就像简单的顺序审批过程一样，流程将会被视为改变状态的一系列步骤，每个步骤都由一个负责人来执行，然后再由其它人员来查看和审核。
示例代码如下：


public class ApprovalWorkflow : IWorkflow

{

public string Id => "ApprovalWorkflow";
 public int Version => 1;
 public void Build(IWorkflowBuilder builder)
 {
 builder
 .StartWith(context => ExecutionResult.Next())
 .Then()
 .Input(step => step.Signature, data => $"{data.Approver}: Approved")
 .Output(data => data.Signatures, step => (step.Signature, step.Name))
 .ForEach(data => data.Reviewers, iteration => iteration
 .Do(branch => branch
 .StartWith()
 .Input(step => step.Request, data => $"Please review {data.DocumentName}")
 .Input(step => step.Requester, data => data.Requester)
 .Then(context =>
 {
 Console.WriteLine($"Request sent to {context.Workflow.Id}");
 return ExecutionResult.Next();
 })
 )
 .While(data => !data.Appro
原创文章，作者：小蓝，如若转载，请注明出处：https://www.506064.com/n/179941.html
 赞 (0)

 打赏 

微信扫一扫
微信扫一扫 

支付宝扫一扫
支付宝扫一扫 



小蓝的头像小蓝  

 0   0





 上一篇
2024-11-22 05:10



下一篇 
2024-11-22 05:10
发表回复 
登录后才能评论