[.NET项目实战] Elsa开源工作流组件应用（三）：实战演练

已于 2024-03-25 18:09:49 修改
阅读量1k 收藏 18
点赞数 16
分类专栏： .NET 文章标签： .net workflow 工作流
于 2024-03-20 18:32:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jevonsflash/article/details/136885255
版权

文章目录

补充

之前的文章简单介绍了工作流和Elsa工作流库，这里再补充说明两点

  1. 工作流的使用场景非常广泛，几乎涵盖了所有需要进行业务流程自动化管理的领域。

  2. 学习一个开源库，最简单的方法就是看源码，Elsa的工作流引擎源码非常简单易懂，并且提供了非常丰富的示例代码，举一个例子：审批工作流示例.\src\samples\aspnet\Elsa.Samples.AspNet.DocumentApproval

在这里插入图片描述
这个审批流是这样的：
作者发来一个文章，有两个审批人需要全部审批通过，文章才算通过，否则退回。

我们尝试阅读工作流源代码DocumentApprovalWorkflow.cs，并运行此项目，用postman发送请求

第一步：

假设这名叫Amanda的作者要发布文章，请求发送后，作者浏览器显示发送成功稍安勿躁之类的提示

同时后台打印作者信息和4个链接，分别是Jack和Lucy两位审批人“通过”和“退回”的url链接

Activities =
{
    new HttpEndpoint
    {
        Path = new("/documents"),
        SupportedMethods = new(new[] { HttpMethods.Post }),
        ParsedContent = new(documentVariable),
        CanStartWorkflow = true
    },
    new WriteLine(context => $"Document received from {documentVariable.Get<dynamic>(context)!.Author.Name}."),
    new WriteHttpResponse
    {
        Content = new("<h1>Request for Approval Sent</h1><p>Your document has been received and will be reviewed shortly.</p>"),
        ContentType = new(MediaTypeNames.Text.Html),
        StatusCode = new(HttpStatusCode.OK),
        ResponseHeaders = new(new HttpHeaders { ["X-Powered-By"] = new[] { "Elsa 3.0" } })
    },

第二步：

Jack觉得文章不错，通过浏览器请求了“通过”链接，而Lucy觉得文章还不够好，需改进，她在浏览器中请求了“退回”链接。

两位审批人的审批结果存储于approvedVariable变量中

同时他们的浏览器返回的响应内容：Thanks for the approval 或 Sorry to hear that

    new Fork
    {
        JoinMode = ForkJoinMode.WaitAll,
        Branches =
        {
            // Jack
            new Sequence
            {
                Activities =
                {
                    new WriteLine(context => $"Jack approve url: \n {GenerateSignalUrl(context, "Approve:Jack")}"),
                    new WriteLine(context => $"Jack reject url: \n {GenerateSignalUrl(context, "Reject:Jack")}"),
                    new Fork
                    {
                        JoinMode = ForkJoinMode.WaitAny,
                        Branches =
                        {
                            // Approve
                            new Sequence
                            {
                                Activities =
                                {
                                    new Event("Approve:Jack"),
                                    new SetVariable
                                    {
                                        Variable = approvedVariable,
                                        Value = new(true)
                                    },
                                    new WriteHttpResponse
                                    {
                                        Content = new("Thanks for the approval, Jack!"),
                                    }
                                }
                            },

                            // Reject
                            new Sequence
                            {
                                Activities =
                                {
                                    new Event("Reject:Jack"),
                                    new SetVariable
                                    {
                                        Variable = approvedVariable,
                                        Value = new(false)
                                    },
                                    new WriteHttpResponse
                                    {
                                        Content = new("Sorry to hear that, Jack!"),
                                    }
                                }
                            }
                        }
                    }
                }
            },

            // Lucy
            new Sequence
            {
                Activities =
                {
                    new WriteLine(context => $"Lucy approve url: \n {GenerateSignalUrl(context, "Approve:Lucy")}"),
                    new WriteLine(context => $"Lucy reject url: \n {GenerateSignalUrl(context, "Reject:Lucy")}"),
                    new Fork
                    {
                        JoinMode = ForkJoinMode.WaitAny,
                        Branches =
                        {
                            // Approve
                            new Sequence
                            {
                                Activities =
                                {
                                    new Event("Approve:Lucy"),
                                    new SetVariable
                                    {
                                        Variable = approvedVariable,
                                        Value = new(true)
                                    },
                                    new WriteHttpResponse
                                    {
                                        Content = new("Thanks for the approval, Lucy!"),
                                    }
                                }
                            },

                            // Reject
                            new Sequence
                            {
                                Activities =
                                {
                                    new Event("Reject:Lucy"),
                                    new SetVariable
                                    {
                                        Variable = approvedVariable,
                                        Value = new(false)
                                    },
                                    new WriteHttpResponse
                                    {
                                        Content = new("Sorry to hear that, Lucy!"),
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    },

第三步：

根据approvedVariable变量判定文章是否被审核通过。

如果通过则在控制台打印Document document-1 approved!, 否则打印Document document-1 rejected!

    new WriteLine(context => $"Approved: {approvedVariable.Get<bool>(context)}"),
    new If(context => approvedVariable.Get<bool>(context))
    {
        Then = new WriteLine(context => $"Document ${documentVariable.Get<dynamic>(context)!.Id} approved!"),
        Else = new WriteLine(context => $"Document ${documentVariable.Get<dynamic>(context)!.Id} rejected!")
    }
}

Elsa工作流源码还提供了大量的Sample，这里就不一一列举了，

需求描述

根据不同的时间规则，发送下发问卷给客户填写。

下发问卷给用户填写，且填写有超时时间，期间要提醒用户答题，

如果问卷未在规定的时间内作答则，则作废，并提醒用户。

需求分析

我们将需求尽可能分解成为单一职责的功能单元，并定义这些功能单元的输入输出。

下发问卷任务 PublishQuestionnaireActivity

下发问卷是将问卷（Questionnaire）实例化成问卷实例（Survey），问卷实例绑定用户Id，用户在问卷实例上作答。明确输入和输出：

  • 输入：问卷ID
  • 输出：问卷实例对象SurveyDto

通知任务 NotificationActivity

通知在这个需求中需要发送问卷状态，时间等内容给对应的用户，同通至少包含标题和内容。

  • 输入：标题和内容
  • 输出：无

问卷状态跟踪任务 WaitFillInSurveyActivity

这个任务要追踪问卷实例的状态，当问卷实例状态为已完成时，可以继续执行后续任务。

  • 输入：问卷实例ID
  • 输出：无

定时和延时任务

用于延时执行每个下发问卷的时间，等待问卷超时，以及延时发送通知等。

  • 输入：开始日期，延时日期，间隔时间或cron表达式
  • 输出：无

根任务

根任务包含所有的子任务，完成这个任务后，整个流程结束。在这个需求中根任务只需要知道将什么问卷，发送给哪位用户，以及在何时发送这三个问题。

  • 输入：问卷ID，用户ID，发送时间
  • 输出：无

各子任务参数对于他们的根任务是透明的（Invisible），根任务只需要关心是否完成，而不需要知道任务参数。

代码实现

下发问卷活动 PublishQuestionnaireActivity

下发问卷任务可以抽象成为下发问卷活动 PublishQuestionnaireActivity
创建PublishQuestionnaireActivity类并设置输入QuestionnaireId，输出SurveyDto

public class PublishQuestionnaireActivity : Activity<SurveyDto>
{
    public PublishQuestionnaireActivity()
    {

    }
    public PublishQuestionnaireActivity(long questionnaireId)
    {
        QuestionnaireId = new Input<long>(questionnaireId);
    }


    
    public Input<long> QuestionnaireId { get; set; } = default!;
}

重写ExecuteAsync方法，完成问卷下发逻辑

protected override async ValueTask ExecuteAsync(ActivityExecutionContext context)
{
    var _surveyAppService = context.GetRequiredService<ISurveyAppService>();
    if (_surveyAppService != null)
    {
        var currentUserId = await context.GetInputValueAsync<Guid>("UserId");
        var survey = await _surveyAppService.PublishAsync(new PublishInput()
        {
            QuestionnaireId = this.QuestionnaireId.Get<long>(context),
            UserId = currentUserId

        }) ?? throw new Exception("创建问卷失败");
        context.SetResult(survey);
    }


    await context.CompleteActivityAsync();

}

如此，其他的任务分别抽象成为相应的活动，这里展示完整代码

通知活动：NotificationActivity

public class NotificationActivity : Activity
{


    public NotificationActivity()
    {

    }
    public NotificationActivity(string title, string content)
    {
        Content = new Input<string>(content);
        Title = new Input<string>(title);
    }

    protected override async ValueTask ExecuteAsync(ActivityExecutionContext context)
    {
        var notificationManager = context.GetRequiredService<NotificationManager>();

        if (notificationManager != null)
        {
            var title = this.Title.Get(context);
            var content = this.Content.Get(context);
            var currentUserId = await context.GetInputValueAsync<Guid>("UserId");
            var data = new CreatePrivateMessageNotificationEto(currentUserId, title, content);
            await notificationManager.Send(data);
        }


    await context.CompleteActivityAsync();

}

    public Input<string> Title { get; set; } = default!;
    public Input<string> Content { get; set; } = default!;
}

等待问卷完成活动：WaitFillInSurveyActivity

public class WaitFillInSurveyActivity : Activity
{
    public WaitFillInSurveyActivity()
    {

    }
    public WaitFillInSurveyActivity(Func<ExpressionExecutionContext, long?> surveyId)
: this(Expression.DelegateExpression(surveyId))
    {
    }

    public WaitFillInSurveyActivity(long surveyId) => SurveyId = new Input<long>(surveyId);

    public WaitFillInSurveyActivity(Expression expression) => SurveyId = new Input<long>(expression, new MemoryBlockReference());


    /// <inheritdoc />
    protected override ValueTask ExecuteAsync(ActivityExecutionContext context)
    {
        var surveyId = SurveyId.Get(context);
        if (surveyId == default)
        {
            var survey = context.ExpressionExecutionContext.GetLastResult<SurveyDto>();
            surveyId = survey.Id;
        }
        var payload = new WaitFillInSurveyBookmarkPayload(surveyId);
        context.CreateBookmark(new CreateBookmarkArgs
        {
            Payload = payload,
            Callback = Resume,
            BookmarkName = Type,
            IncludeActivityInstanceId = false
        });
        return ValueTask.CompletedTask;
    }

    private async ValueTask Resume(ActivityExecutionContext context)
    {
        await context.CompleteActivityAsync();
    }

    public Input<long> SurveyId { get; set; } = default!;
}

此任务需要等待，我们创建一个Bookmark，注意创建Bookmark时，我们根据问卷实例SurveyId判断是否完成问卷的回答，因此指定IncludeActivityInstanceId为false，创建携带SurveyId的Payload类型：

public record WaitFillInSurveyBookmarkPayload(long SurveyId);

在回调OnResumeAsync中，我们使用context.CompleteActivityAsync来完成任务。

定时和延时活动：

Elsa.Scheduling库提供了用于定时和延时任务的触发器（触发器属于工作流的一种）

在这里插入图片描述

在[.NET项目实战] Elsa开源工作流组件应用（二）：内核解读 一文 "构建 - 构建活动 "章节 列出了Elsa所有内建的活动。

这里使用Elsa内建的三个触发器：

StartAt 在未来特定的时间戳触发工作流触发器
Delay 延迟执行工作流触发器。
Timer 定期触发工作流触发器。

问卷活动：QuestionnaireActivity

问卷活动是下发问卷，通知，等待填写问卷等活动的父级。

Elsa定义了容器类型的活动Container类型，其中的Activities可以包含其他活动。

在这里插入图片描述

Sequence和Parallel都是容器类型，是Activity的子类，它们分别表示并行和顺序执行。

除此之外我们还需要两个内建活动：

Fork：分支，用于分支并行执行，与Parallel类似，但比它多了一个等待完成功能。

通过ForkJoinMode属性，可以指定分支任务的执行方式，ForkJoinMode.WaitAny：等待任意一个任务完成，ForkJoinMode.WaitAll：等待所有任务完成。

Fault：故障，用于在工作流执行过程中，遇到异常时，触发故障。并结束工作流。

创建问卷活动类型QuestionnaireActivity，继承自Sequence类型，并设置一些属性，如问卷Id，问卷填写超时时间等。

[可选]Elsa在注册工作流时，Activity对象是会被序列化并存储到WorflowDefinition表中的， 因此这些属性可以被持久化到数据库中。

public class QuestionnaireActivity : Sequence
{
    //可选，用于持久化一些属性
    public TimeSpan Delay { get; set; }
    public DateTime StartAt { get; set; }
    public TimeSpan Interval { get; set; }
    public string Cron { get; set; }
    public TimeSpan Duration { get; set; }
    public long QuestionnaireId { get; set; }
    public TimeSpan FillInTimeout { get; set; } = TimeSpan.FromHours(2);

    public QuestionnaireActivity()
    {

    }   
}

重写构造函数，并设置Activities属性

public QuestionnaireActivity(long questionnaireId, TimeSpan fillInTimeout)
{
    this.QuestionnaireId = questionnaireId;
    this.FillInTimeout = fillInTimeout;
    var currentSurvey = new Variable<SurveyDto>();
    Variables.Add(currentSurvey);
    Activities = new List<IActivity>()
    {
        //流程开始打印
        new WriteLine("问卷流程开始"),

        //下发问卷任务
        new PublishQuestionnaireActivity(QuestionnaireId)
        {
            Name="PublishQuestionnaire",
            Result=new Output<Questionnaire.Survey.Dto.SurveyDto> (currentSurvey)
        },
        //问卷到达提醒             
        new NotificationActivity("新问卷提醒", "您有新的问卷，请查收"),

        //问卷处理分支 
        new Fork
        {
            JoinMode = ForkJoinMode.WaitAny,
            Branches =
            {
                //问卷即将过期提醒 
                new Sequence
                {
                    Activities =
                    {
                        //等待
                        new Delay
                        {
                            Name = "RemindDelay",
                            TimeSpan = new(RemindDelay)
                        },
                        //通知
                        new NotificationActivity("问卷即将超时", "问卷即将超时，请尽快回答")
                    }
                },
                //问卷过期处理以及提醒 
                new Sequence
                {
                    Activities =
                    {
                        //等待
                        new Delay
                        {
                            Name = "TimeoutDelay",
                            TimeSpan = new(FillInTimeout)
                        },
                        //通知
                        new NotificationActivity("问卷已过期", "问卷已过期，请等待工作人员处理"),

                        //处理
                        new Fault()
                        {
                            Message=new ("问卷回答超时")
                        }
                    }
                },
                //问卷状态跟踪 
                new Sequence
                {
                    Activities =
                    {
                        new WriteLine("开始等待问卷提交信号"),
                        new WaitFillInSurveyActivity(context => currentSurvey.Get<SurveyDto>(context)?.Id)

                    }
                }
            }
        },
        //流程结束打印 
        new WriteLine("完成流程结束"),
        new Finish(),
    };
}

创建工作流

现在我们来创建测试工作流，

  1. 添加一个工作流参数UserId，用于各活动中对用户的查询依赖。
  2. 分别实现4个并行任务：延时发送问卷，定时发送问卷，定期间隔发送问卷，根据Cron表达式执行。和一个串行任务
public class Test1Workflow : WorkflowBase
{
    public Guid UserId { get; set; }
    protected override void Build(IWorkflowBuilder workflow)
    {
        var startTime = new Variable<DateTimeOffset>();
        workflow.Inputs.Add(
                    new InputDefinition() { Name = "UserId", Type = typeof(Guid), StorageDriverType = typeof(WorkflowStorageDriver) }
            );
        workflow.WithVariable(startTime);

        workflow.Root = new Sequence
        {
            Activities =
                {
                    new WriteLine("Start"),
                    new SetVariable<DateTimeOffset>
                    {
                        Variable = startTime,
                        Value = new (DateTime.Now )
                    },
                    
                    new Parallel()
                    {
                        Activities =
                        {
                            //并行任务1：延时发送问卷
                            new Sequence()
                            {
                                Activities =
                                {
                                    //问卷1 将在工作流启动后1小时执行

                                    new Delay(TimeSpan.FromHours(1)),
                                    new QuestionnaireActivity(1),
                                }
                            },
                            //并行任务2：定时发送问卷
                            new Sequence()
                            {
                                Activities =
                                {
                                    //问卷2 将在 2024-4-1 08:30:00 执行
                                    new StartAt(new DateTime(2024,4,1,8,30,0)),
                                    new Delay(TimeSpan.FromHours(2)),
                                    new QuestionnaireActivity(2),
                                }
                            },
                            //并行任务3：定期间隔发送问卷
                            new Sequence()
                            {
                                Activities =
                                {
                                    //问卷3 每隔两个小时执行
                                    new Timer(new TimeSpan(2,0,0)),

                                    new Delay(TimeSpan.FromHours(2)),
                                    new QuestionnaireActivity(3),
                                }
                            },
                            //并行任务4：根据Cron表达式执行
                            new Sequence()
                            {
                                Activities =
                                {
                                    //问卷4 每个月的最后一天上午10点执行任务
                                    new Cron(cronExpression:"0 0 10 L * ?"),

                                    new Delay(TimeSpan.FromHours(2)),
                                    new QuestionnaireActivity(4),
                                }
                            },
                            //并行任务5：根据某时间发送问卷
                            new Sequence()
                            {
                                Activities =
                                {
                                    new StartAt(context=> startTime.Get(context).AddMinutes(90)),

                                    new Delay(TimeSpan.FromHours(2)),
                                    new QuestionnaireActivity(5),
                                }
                            },



                            //串行任务
                            new Sequence()
                            {
                                Activities =
                                {
                                    //问卷3 将在工作流启动后2小时执行

                                    new Delay(TimeSpan.FromHours(2)),
                                    new QuestionnaireActivity(3),

                                        //问卷4 将在问卷3完成1天后执行

                                    new Delay(TimeSpan.FromDays(1)),
                                    new QuestionnaireActivity(4),

                                    //问卷5 将在问卷4完成3天后执行

                                    new Delay(TimeSpan.FromDays(3)),
                                    new QuestionnaireActivity(5),
                                }
                            }
                        }
                    },
                    new Finish(),
            },
        };
    }
}

开始工作流

工作流启动参数需设置Input对象


var input = new Dictionary<string, object>
{

    {"UserId", "D1522DBC-5BFC-6173-EB60-3A114454350C"},

};

var startWorkflowOptions = new StartWorkflowRuntimeOptions
{
    Input = input,
    VersionOptions = versionOptions,
    InstanceId = instanceId,
};


// Start the workflow.
var result = await _workflowRuntime.StartWorkflowAsync(workflowDefinition.DefinitionId, startWorkflowOptions);

下面进入喜闻乐见的踩坑填坑环节

TroubleShooting

  1. 在活动中执行异步操作时，会导致报错：

    如下面的代码，执行Excute方法中的 context.CompleteActivityAsync()方法，时报错

在这里插入图片描述

在这里插入图片描述

原因分析：scope资源被提前释放

代码先执行到了112行，scope释放

在这里插入图片描述

解决：带有异步的操作一定要使用ExecuteAsync方法

在这里插入图片描述

  1. delay之后，Workflow的Input无法访问

原因分析：

Delay或其他Schedule类型的Activity，通过创建Bookmark挂起任务，当任务被唤醒时，input被workflowState.Output替换掉，和原先的input不一样了。

在这里插入图片描述

解决：

虽然input被替换了，但数据库的input还在，可以通过workflowInstanceId先取回workflowInstance对象，再通过instance.WorkflowState.Input.TryGetValue方法获取原始input值。

可以创建一个一个扩展方法GetInputValueAsync，Delay之后的活动中调用即可。

public static async Task<TValue> GetInputValueAsync<TValue>(this ActivityExecutionContext context, string name)
{
    TValue value;
    if (!context.TryGetWorkflowInput(name, out value))
    {
        var workflowInstanceStore = context.GetRequiredService<IWorkflowInstanceStore>();

        var instance = await workflowInstanceStore.FindAsync(new WorkflowInstanceFilter()
        {
            Id = context.WorkflowExecutionContext.Id

        });
        if (instance != null)
        {
            instance.WorkflowState.Input.TryGetValue(name, out value);
        }
    }

    return value;


}

在Activity中调用：

await context.GetInputValueAsync<Guid>("UserId");

持续更新中…

–完结–

林晓lx
关注
  • 16
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
推荐一款可在.net中使用的工作流
A_nanda的博客
04-12 1058
虽然可以使用逻辑应用实现长时间运行的工作流，但通常将工作流与多个逻辑应用拆分，其中一个工作流调用另一个逻辑应用。使用 Elsa，您只需在工作流程中的任何位置添加触发器，从而更轻松地全面了解您的应用程序逻辑。为了管理工作流定义和实例，Elsa 附带了一个可重用的 Razor 类库，该库以 MVC 区域的形式提供了一个仪表板应用程序，您可以将其包含在自己的 ASP.NET Core 应用程序中。另一方面，Elsa 不仅允许您在 Azure 上托管它，还允许您在任何支持 .NET Core 的云提供商上托管它。
.NET工作流源码架构（100%可用）
12-20
工作流源代码架构，全部源码开放，100%可执行。如有缺失文档请在http://www.chinae8.net/front/down 下载
两款开源.NET工作流引擎 Elsa 与ccflow使用比较
驰骋工作流的博客
01-09 3897
相对java开源的工作流程引擎.net开源的工作流程引擎相对较少，这里整理两款.net开源工作流引擎，做一下对比使用。 elsa示例代码:Githubd地址：https://github.com/zhenl/MyElsa ccflow下载地址：https://gitee.com/opencc/ccflow
Elsa Workflows工作流引擎项目构建
实践出真知
11-17 3527
注：本文主要采用.NET 6和Elsa工作引擎进行编写。
探索Elsa 3.0：无界工作流的力量！
最新发布
gitblog_00100的博客
05-11 468
探索Elsa 3.0：无界工作流的力量！ 项目地址:https://gitcode.com/elsa-workflows/elsa-core Elsa 3.0 是一个强大的.NET工作流库，它赋予你的应用程序执行工作流的能力。无论是编写C#代码，使用视觉设计界面，还是在JSON中定义流程，Elsa都为你的业务逻辑提供了无限的灵活性。 尝试Docker快速启动： docker pull elsaw...
[学习笔记] WorkFlow工作流实现审批流程
u014364227的博客
03-05 1450
审批流程分为两级审批，提交审批后先交由核保员审批，审批通过后再交由领导审批，若核保员审批不通过则直接结束。审批时需要传入角色Code，与任务所绑定的候选组进行匹对，方有权限审批。审批即根据传入的结果，对任务绑定结果变量approved。网关会根据变量的值选择对应分支（流程图中设置的流条件）注 创建时需要传入流程模型id，可在xml文件中查看。创建后可返回流程实例与申请单绑定，以便于后续的查询。WorkFlow为我们提供了相关的操作业务类。流程引擎会解析某路径下的流程模型文件。
工作流引擎之Elsa入门系列教程之一 初始化项目并创建第一个工作流.doc
07-13
工作流引擎之Elsa入门系列教程之一 初始化项目并创建第一个工作流.doc
基于asp.net+C#开发的工作流平台superflow最新版本V6.5-20150104
01-07
基于asp.net+C#开发的工作流平台superflow最新版本V6.5-20150104，该平台具有独立的工作流引擎，提供纯BS结构的工作流程设计器，工作流表单设计器，以及提供工作流审批系统所需要的应用系统二次开发框架，提供强大的工作流引擎开发组件包，提供审批系统需要的组织机构可视化定义管理，工作流用户与角色管理，工作流表单权限管理等。
[.NET项目实战] Elsa开源工作流组件应用（二）：内核解读
jevonsflash的专栏
03-20 1192
Elsa工作原理可以抽象理解为管道中间件 + 异步模型Elsa中，活动的变量的获取和设置都是异步的。Elsa定义了Variable类型作为异步操作的结果或者说是异步操作的占位符，这个变量在运行的时候才会填充数值。这与我们熟悉C#中的Task，或者js里的promise对象作用相同。输入Input，OutPut都属于 Variable。Elsa模拟了内存寄存器（MemoryRegister）以及Set和Get访问器实现异步模型。
Elsa依据工作流程Id实例化工作流并调用相关节点信号量执行
dacong的专栏
08-13 610
Elsa依据工作流程Id实例化工作流并调用相关节点信号量执行。
通过asp.net core 页面发起Elsa工作流
08-20
通过asp.net core 页面发起Elsa工作流 工作流持久化，手工启动
elsa-guides:《 Elsa工作流程指南》所引用的示例项目的集合
05-08
艾尔莎指南 《 Elsa工作流程指南》所引用的示例项目的集合
elsa-core：一个.NET Standard 2.0工作流库
02-04
艾尔莎（Elsa）工作流程 Elsa Core是一个工作流库，可在任何.NET Core应用程序中执行工作流。 工作流不仅可以使用代码定义，还可以定义为JSON，YAML或XML。 开始使用 请遵循上的“ 。 路线图 版本1.0 工作流程调用者 长期运行的工作流 工作流为代码 工作流作为数据 相关性 持久性：CosmosDB，实体框架核心，MongoDB，YesSQL HTML5 Workflow Designer Web组件 ASP.NET Core工作流程仪表板 JavaScript表达式 液体表达 原始活动 控制流活动 工作流程活动 计时器活动 HTTP活
Elsa-Workflow
03-31
艾尔莎工作流程 使用Elsa和.NET Core的工作流驱动的测试应用程序 基于。 运行之前： 此实现使用mongoDB连接。 可以在appsettings.json配置连接URL。 在运行应用程序之前，请确保对其进行调整。 在/Workflows文件夹中可以找到为此示例设计的/Workflows 。 运行项目后，首先需要通过Elsa的Dashboard界面导入工作流程定义。 此工作流程的一个示例随同该文件夹内的json文件一起附加。 在/users/register上执行POST操作后触发工作流。 卷曲示例： curl --location --request POST 'https://localhost:44306/users/register' \ --header 'Content-Type: application/json' \ --header 'Content-
两款开源.NET工作流引擎 Elsa与ccflow使用比较.docx
01-09
相对java开源的工作流程引擎.net开源的工作流程引擎相对较少，这里整理两款.net开源工作流引擎，做一下对比使用。 elsa示例代码:Githubd地址：https://github.com/zhenl/MyElsa ccflow下载地址：...
Elsa-审批流实现
码农的专栏
02-12 3864
一、新建项目：ElsaFlowDemo <Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <OutputType>Exe</OutputType> <TargetFramework>netcoreapp3.1</TargetFramework> </PropertyGroup> <ItemGroup> <Proje
小试elsa
dotNET跨平台
01-12 722
最近工作需要，在调研BMP产品（开源和商用），重点了解了activiti和它的商业产品Alfresco Process Services，这是java的体系，成熟，完善(三方开源库是ja...
.NET 5 开源工作流框架elsa技术研究
dotNET跨平台
01-02 6184
编者注：工作流框架 elsa 是.NET基金会下面的开源项目，2.0版本即将在3月份发布，目前正在紧锣密鼓的开发之中，2020年2月份我也介绍过推荐一个很棒的开源工作流elsa-cor...
使用.net 构建 Elsa Workflow
cao919的专栏Net
11-12 2366
对接过蓝凌OA 也基于泛微OA数据库原型重新研发上线过产品，自研的开源的也上线过 每个公司对OA流程引擎介绍 都不一样的， 比如Elsa 这块微软MVP 开源产品 这个，基于跨平台开发的技术含量高，专门做OA的同行推过对应文章。二章 改成API 使用的预发行版本 即还没有成为正式发布的版本！然后就潜规则 官网居然 直接就 下一页 不告诉怎么搞了 哈哈哈哈。---分割线------------------------已知的是1用这个就能拿到token了还要其他干啥。三章 开始用用核心点的东西了。
python将['I', 'like', 'the', ' Anna ', 'sisters:', 'and', 'Elsa']转换为I like the sisters: Anna and Elsa
04-26
可以使用以下代码将其转换： ```python lst = ['I', 'like', 'the', ' Anna ', 'sisters:', 'and', 'Elsa'] lst[3] = 'Anna' lst.insert(5, 'and') result = ' '.join(lst) print(result) ``` 输出结果为：I like the sisters: Anna and Elsa

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林晓lx

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值