实现顺序聊天流

若要使用对话，请安装 Microsoft.Bot.Builder.Dialogs NuGet 包。

机器人通过 UserProfileDialog 来与用户交互。 创建机器人的 DialogBot 类时，UserProfileDialog 将设置为其主对话。 然后，机器人使用 Run 帮助器方法来访问该对话。

Dialogs\UserProfileDialog.cs

首先创建派生自 UserProfileDialog 类的 ComponentDialog，这包括 7 个步骤。

在 UserProfileDialog 构造函数中创建瀑布步骤、提示和瀑布对话，然后将其添加到对话集。 提示需要位于使用这些提示的同一对话集中。

public UserProfileDialog(UserState userState)
    : base(nameof(UserProfileDialog))
{
    _userProfileAccessor = userState.CreateProperty<UserProfile>("UserProfile");

    // This array defines how the Waterfall will execute.
    var waterfallSteps = new WaterfallStep[]
    {
        TransportStepAsync,
        NameStepAsync,
        NameConfirmStepAsync,
        AgeStepAsync,
        PictureStepAsync,
        SummaryStepAsync,
        ConfirmStepAsync,
    };

    // Add named dialogs to the DialogSet. These names are saved in the dialog state.
    AddDialog(new WaterfallDialog(nameof(WaterfallDialog), waterfallSteps));
    AddDialog(new TextPrompt(nameof(TextPrompt)));
    AddDialog(new NumberPrompt<int>(nameof(NumberPrompt<int>), AgePromptValidatorAsync));
    AddDialog(new ChoicePrompt(nameof(ChoicePrompt)));
    AddDialog(new ConfirmPrompt(nameof(ConfirmPrompt)));
    AddDialog(new AttachmentPrompt(nameof(AttachmentPrompt), PicturePromptValidatorAsync));

    // The initial child Dialog to run.
    InitialDialogId = nameof(WaterfallDialog);
}

接下来，添加由对话用于提示输入的步骤。 若要使用提示，请从对话中的某个步骤调用它，然后使用 stepContext.Result 检索下一步骤中的提示结果。 在幕后，提示是由两个步骤组成的对话。 首先，提示要求提供输入。 然后它返回有效值，或者使用重新提示从头开始，直到收到有效的输入为止。

应始终从瀑布步骤返回非 null 的 DialogTurnResult。 否则，对话可能不按设计意图运行。 下面显示了瀑布对话中 NameStepAsync 的实现。

private static async Task<DialogTurnResult> NameStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    stepContext.Values["transport"] = ((FoundChoice)stepContext.Result).Value;

    return await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = MessageFactory.Text("Please enter your name.") }, cancellationToken);
}

在 AgeStepAsync 中，指定当用户输入采用的是提示无法分析的格式，或者不符合验证条件，因而无法验证时，要使用的重试提示。 在这种情况下，如果未提供重试提示，则提示将使用初始提示文本来重新提示用户输入。

private async Task<DialogTurnResult> AgeStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    if ((bool)stepContext.Result)
    {
        // User said "yes" so we will be prompting for the age.
        // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
        var promptOptions = new PromptOptions
        {
            Prompt = MessageFactory.Text("Please enter your age."),
            RetryPrompt = MessageFactory.Text("The value entered must be greater than 0 and less than 150."),
        };

        return await stepContext.PromptAsync(nameof(NumberPrompt<int>), promptOptions, cancellationToken);
    }
    else
    {
        // User said "no" so we will skip the next step. Give -1 as the age.
        return await stepContext.NextAsync(-1, cancellationToken);
    }
}

UserProfile.cs

用户的交通方式、姓名和年龄将保存在 UserProfile 类的实例中。

public class UserProfile
{
    public string Transport { get; set; }

    public string Name { get; set; }

    public int Age { get; set; }

    public Attachment Picture { get; set; }
}

Dialogs\UserProfileDialog.cs

最后一个步骤检查前一瀑布步骤中调用的对话返回的 stepContext.Result。 如果返回值为 true，则个人资料访问器将获取并更新用户个人资料。 若要获取用户个人资料，请调用 GetAsync，然后设置 userProfile.Transport、userProfile.Name、userProfile.Age 和 userProfile.Picture 属性的值。 最后，在调用用于结束对话的 EndDialogAsync 之前汇总用户的信息。 结束对话会从对话堆栈中弹出该对话，并将可选结果返回到该对话的父级。 父级是启动了刚刚结束的对话的对话或方法。

    else
    {
        msg += $" Your profile will not be kept.";
    }

    await stepContext.Context.SendActivityAsync(MessageFactory.Text(msg), cancellationToken);

    // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is the end.
    return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);
}

private async Task<DialogTurnResult> SummaryStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    stepContext.Values["picture"] = ((IList<Attachment>)stepContext.Result)?.FirstOrDefault();

    // Get the current profile object from user state.
    var userProfile = await _userProfileAccessor.GetAsync(stepContext.Context, () => new UserProfile(), cancellationToken);

    userProfile.Transport = (string)stepContext.Values["transport"];
    userProfile.Name = (string)stepContext.Values["name"];
    userProfile.Age = (int)stepContext.Values["age"];
    userProfile.Picture = (Attachment)stepContext.Values["picture"];

    var msg = $"I have your mode of transport as {userProfile.Transport} and your name as {userProfile.Name}";

    if (userProfile.Age != -1)
    {
        msg += $" and your age as {userProfile.Age}";
    }

    msg += ".";

    await stepContext.Context.SendActivityAsync(MessageFactory.Text(msg), cancellationToken);

    if (userProfile.Picture != null)
    {
        try
        {
            await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(userProfile.Picture, "This is your profile picture."), cancellationToken);
        }
        catch
        {
            await stepContext.Context.SendActivityAsync(MessageFactory.Text("A profile picture was saved but could not be displayed here."), cancellationToken);

若要使用对话，项目需要安装 botbuilder-dialogs npm 包。

机器人通过 UserProfileDialog 与用户交互。 创建机器人的 DialogBot 时，UserProfileDialog 将设置为其主对话。 然后，机器人使用 run 帮助器方法来访问该对话。

dialogs/userProfileDialog.js

首先创建派生自 UserProfileDialog 类的 ComponentDialog，这包括 7 个步骤。

在 UserProfileDialog 构造函数中创建瀑布步骤、提示和瀑布对话，然后将其添加到对话集。 提示需要位于使用这些提示的同一对话集中。

class UserProfileDialog extends ComponentDialog {
    constructor(userState) {
        super('userProfileDialog');

        this.userProfile = userState.createProperty(USER_PROFILE);

        this.addDialog(new TextPrompt(NAME_PROMPT));
        this.addDialog(new ChoicePrompt(CHOICE_PROMPT));
        this.addDialog(new ConfirmPrompt(CONFIRM_PROMPT));
        this.addDialog(new NumberPrompt(NUMBER_PROMPT, this.agePromptValidator));
        this.addDialog(new AttachmentPrompt(ATTACHMENT_PROMPT, this.picturePromptValidator));

        this.addDialog(new WaterfallDialog(WATERFALL_DIALOG, [
            this.transportStep.bind(this),
            this.nameStep.bind(this),
            this.nameConfirmStep.bind(this),
            this.ageStep.bind(this),
            this.pictureStep.bind(this),
            this.summaryStep.bind(this),
            this.confirmStep.bind(this)
        ]));

接下来，添加由对话用于提示输入的步骤。 若要使用提示，请从对话中的某个步骤调用它，然后从步骤上下文检索下一步骤中的提示结果（本例使用 step.result）。 在幕后，提示是由两个步骤组成的对话。 首先，提示要求提供输入。 然后它返回有效值，或者使用重新提示从头开始，直到收到有效的输入为止。

应始终从瀑布步骤返回非 null 的 DialogTurnResult。 否则，对话可能不按设计意图运行。 下面显示了瀑布对话中 nameStep 的实现。

}

async nameStep(step) {
    step.values.transport = step.result.value;

在 ageStep 中，指定用户输入在以下情况下使用的重试提示：当输入的格式无法被提示分析，或输入未满足上述构造函数中指定的验证条件。 在这种情况下，如果未提供重试提示，则提示将使用初始提示文本来重新提示用户输入。

}

async ageStep(step) {
    if (step.result) {
        // User said "yes" so we will be prompting for the age.
        // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
        const promptOptions = { prompt: 'Please enter your age.', retryPrompt: 'The value entered must be greater than 0 and less than 150.' };

        return await step.prompt(NUMBER_PROMPT, promptOptions);
    } else {
        // User said "no" so we will skip the next step. Give -1 as the age.
        return await step.next(-1);

userProfile.js

用户的交通方式、姓名和年龄将保存在 UserProfile 类的实例中。

// @ts-check

class UserProfile {
    constructor(transport, name, age, picture) {
        this.transport = transport;
        this.name = name;
        this.age = age;
        this.picture = picture;

dialogs/userProfileDialog.js

最后一个步骤检查前一瀑布步骤中调用的对话返回的 step.result。 如果返回值为 true，则个人资料访问器将获取并更新用户个人资料。 若要获取用户个人资料，请调用 get，然后设置 userProfile.transport、userProfile.name、userProfile.age 和 userProfile.picture 属性的值。 最后，在调用用于结束对话的 endDialog 之前汇总用户的信息。 结束对话会从对话堆栈中弹出该对话，并将可选结果返回到该对话的父级。 父级是启动了刚刚结束的对话的对话或方法。

        msg += ' Your profile will not be kept.';
    }

    await step.context.sendActivity(msg);

    // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
    return await step.endDialog();
}

async summaryStep(step) {
    step.values.picture = step.result && step.result[0];

    // Get the current profile object from user state.
    const userProfile = await this.userProfile.get(step.context, new UserProfile());

    userProfile.transport = step.values.transport;
    userProfile.name = step.values.name;
    userProfile.age = step.values.age;
    userProfile.picture = step.values.picture;

    let msg = `I have your mode of transport as ${ userProfile.transport } and your name as ${ userProfile.name }`;
    if (userProfile.age !== -1) {
        msg += ` and your age as ${ userProfile.age }`;
    }

    msg += '.';
    await step.context.sendActivity(msg);
    if (userProfile.picture) {
        try {
            await step.context.sendActivity(MessageFactory.attachment(userProfile.picture, 'This is your profile picture.'));
        } catch {

创建用于运行瀑布对话的扩展方法

在 run 中定义的 userProfileDialog 帮助器方法用于创建和访问对话上下文。 此处的 accessor 是对话状态属性的状态属性访问器，this 是用户个人资料组件对话。 由于组件对话定义内部对话集，因此我们必须创建可让消息处理程序代码看到的外部对话集，并使用它来创建对话上下文。

对话上下文是通过调用 createContext 方法创建的，用于从机器人轮次处理程序内部来与对话集交互。 对话上下文包含当前轮次上下文、父对话和对话状态。对话状态提供一种方法用于在对话中保留信息。

借助对话上下文可以使用对话的字符串 ID 来启动该对话，或继续当前的对话（例如，包含多个步骤的瀑布对话）。 对话上下文将传递到机器人的所有对话和瀑布步骤。

 * @param {*} accessor
 */
async run(turnContext, accessor) {
    const dialogSet = new DialogSet(accessor);
    dialogSet.add(this);

    const dialogContext = await dialogSet.createContext(turnContext);
    const results = await dialogContext.continueDialog();
    if (results.status === DialogTurnStatus.empty) {
        await dialogContext.beginDialog(this.id);

机器人通过 UserProfileDialog 来与用户交互。 创建机器人的 DialogBot 类时，UserProfileDialog 将设置为其主对话。 然后，机器人使用 Run 帮助器方法来访问该对话。

UserProfileDialog.java

首先创建派生自 UserProfileDialog 类的 ComponentDialog，这包括 7 个步骤。

在 UserProfileDialog 构造函数中创建瀑布步骤、提示和瀑布对话，然后将其添加到对话集。 提示需要位于使用这些提示的同一对话集中。

接下来，添加由对话用于提示输入的步骤。 若要使用提示，请从对话中的某个步骤调用它，然后使用 stepContext.getResult() 检索下一步骤中的提示结果。 在幕后，提示是由两个步骤组成的对话。 首先，提示要求提供输入。 然后它返回有效值，或者使用重新提示从头开始，直到收到有效的输入为止。

应始终从瀑布步骤返回非 null 的 DialogTurnResult。 否则，对话可能不按设计意图运行。 下面显示了瀑布对话中 nameStep 的实现。

在 ageStep 中，指定当用户输入采用的是提示无法分析的格式，或者不符合验证条件，因而无法验证时，要使用的重试提示。 在这种情况下，如果未提供重试提示，则提示将使用初始提示文本来重新提示用户输入。

UserProfile.java

用户的交通方式、姓名和年龄将保存在 UserProfile 类的实例中。

UserProfileDialog.java

最后一个步骤检查前一瀑布步骤中调用的对话返回的 stepContext.Result。 如果返回值为 true，则个人资料访问器将获取并更新用户个人资料。 若要获取用户个人资料，请调用 get，然后设置 userProfile.Transport、userProfile.Name、userProfile.Age 和 userProfile.Picture 属性的值。 最后，在调用用于结束对话的 endDialog 之前汇总用户的信息。 结束对话会从对话堆栈中弹出该对话，并将可选结果返回到该对话的父级。 父级是启动了刚刚结束的对话的对话或方法。

若要使用对话框，请通过在终端运行 和 来安装 pip install botbuilder-dialogs 和 pip install botbuilder-ai 的 PyPI 包。

机器人通过 UserProfileDialog 来与用户交互。 创建机器人的 DialogBot 类时，UserProfileDialog 将设置为机器人的主对话。 然后，机器人使用 run_dialog 帮助器方法来访问该对话。

dialogs\user_profile_dialog.py

首先创建派生自 UserProfileDialog 类的 ComponentDialog，这包括 7 个步骤。

在 UserProfileDialog 构造函数中创建瀑布步骤、提示和瀑布对话，然后将其添加到对话集。 提示需要位于使用这些提示的同一对话集中。

def __init__(self, user_state: UserState):
    super(UserProfileDialog, self).__init__(UserProfileDialog.__name__)

    self.user_profile_accessor = user_state.create_property("UserProfile")

    self.add_dialog(
        WaterfallDialog(
            WaterfallDialog.__name__,
            [
                self.transport_step,
                self.name_step,
                self.name_confirm_step,
                self.age_step,
                self.picture_step,
                self.summary_step,
                self.confirm_step,
            ],
        )
    )
    self.add_dialog(TextPrompt(TextPrompt.__name__))
    self.add_dialog(
        NumberPrompt(NumberPrompt.__name__, UserProfileDialog.age_prompt_validator)
    )
    self.add_dialog(ChoicePrompt(ChoicePrompt.__name__))
    self.add_dialog(ConfirmPrompt(ConfirmPrompt.__name__))
    self.add_dialog(
        AttachmentPrompt(
            AttachmentPrompt.__name__, UserProfileDialog.picture_prompt_validator
        )
    )

    self.initial_dialog_id = WaterfallDialog.__name__

接下来，添加由对话用于提示输入的步骤。 若要使用提示，请从对话中的某个步骤调用它，然后使用 step_context.result 检索下一步骤中的提示结果。 在幕后，提示是由两个步骤组成的对话。 首先，提示要求提供输入。 然后它返回有效值，或者使用重新提示从头开始，直到收到有效的输入为止。

应始终从瀑布步骤返回非 null 的 DialogTurnResult。 否则，对话可能不按设计意图运行。 在此处可以看到瀑布对话中 name_step 的实现。

async def name_step(self, step_context: WaterfallStepContext) -> DialogTurnResult:
    step_context.values["transport"] = step_context.result.value

    return await step_context.prompt(
        TextPrompt.__name__,
        PromptOptions(prompt=MessageFactory.text("Please enter your name.")),
    )

在 age_step 中，指定用户输入在以下情况下使用的重试提示：当输入的格式无法被提示分析，或输入未满足上述构造函数中指定的验证条件。 在这种情况下，如果未提供重试提示，则提示将使用初始提示文本再次提示用户输入

async def age_step(self, step_context: WaterfallStepContext) -> DialogTurnResult:
    if step_context.result:
        # User said "yes" so we will be prompting for the age.
        # WaterfallStep always finishes with the end of the Waterfall or with another dialog,
        # here it is a Prompt Dialog.
        return await step_context.prompt(
            NumberPrompt.__name__,
            PromptOptions(
                prompt=MessageFactory.text("Please enter your age."),
                retry_prompt=MessageFactory.text(
                    "The value entered must be greater than 0 and less than 150."
                ),
            ),
        )

    # User said "no" so we will skip the next step. Give -1 as the age.
    return await step_context.next(-1)

data_models\user_profile.py

用户的交通方式、姓名和年龄将保存在 UserProfile 类的实例中。

class UserProfile:
    """
      This is our application state. Just a regular serializable Python class.
    """

    def __init__(self, name: str = None, transport: str = None, age: int = 0, picture: Attachment = None):
        self.name = name
        self.transport = transport
        self.age = age
        self.picture = picture

dialogs\user_profile_dialog.py

最后一个步骤检查前一瀑布步骤中调用的对话返回的 step_context.result。 如果返回值为 true，则个人资料访问器将获取并更新用户个人资料。 若要获取用户个人资料，请调用 get，然后设置 user_profile.transport、user_profile.name 和 user_profile.age 属性的值。 最后，在调用用于结束对话的 end_dialog 之前汇总用户的信息。 结束对话会从对话堆栈中弹出该对话，并将可选结果返回到该对话的父级。 父级是启动了刚刚结束的对话的对话或方法。

async def summary_step(
    self, step_context: WaterfallStepContext
) -> DialogTurnResult:
    step_context.values["picture"] = (
        None if not step_context.result else step_context.result[0]
    )
    # Get the current profile object from user state.  Changes to it
    # will saved during Bot.on_turn.
    user_profile = await self.user_profile_accessor.get(
        step_context.context, UserProfile
    )

    user_profile.transport = step_context.values["transport"]
    user_profile.name = step_context.values["name"]
    user_profile.age = step_context.values["age"]
    user_profile.picture = step_context.values["picture"]

    msg = f"I have your mode of transport as {user_profile.transport} and your name as {user_profile.name}."
    if user_profile.age != -1:
        msg += f" And age as {user_profile.age}."

    await step_context.context.send_activity(MessageFactory.text(msg))

    if user_profile.picture:
        await step_context.context.send_activity(
            MessageFactory.attachment(
                user_profile.picture, "This is your profile picture."
            )
        )
    else:
        await step_context.context.send_activity(
            "A profile picture was saved but could not be displayed here."
        )

    # WaterfallStep always finishes with the end of the Waterfall or with another
    # dialog, here it is the end.
    return await step_context.prompt(
        ConfirmPrompt.__name__,

创建用于运行瀑布对话的扩展方法

run_dialog() 帮助器方法在 helpers\dialog_helper.py 中定义，用于创建和访问对话上下文。 此处的 accessor 是对话状态属性的状态属性访问器，dialog 是用户个人资料组件对话。 由于组件对话定义内部对话集，因此我们必须创建可让消息处理程序代码看到的外部对话集，并使用它来创建对话上下文。

通过调用 create_context 创建对话上下文，用于从机器人轮次处理程序内部来与对话集交互。 对话上下文包含当前轮次上下文、父对话和对话状态。对话状态提供一种方法用于在对话中保留信息。

通过对话上下文，你可以使用字符串 ID 启动对话，也可以继续当前的对话（例如，包含多个步骤的瀑布对话）。 对话上下文将传递到机器人的所有对话和瀑布步骤。

class DialogHelper:
    @staticmethod
    async def run_dialog(
        dialog: Dialog, turn_context: TurnContext, accessor: StatePropertyAccessor
    ):
        dialog_set = DialogSet(accessor)
        dialog_set.add(dialog)

        dialog_context = await dialog_set.create_context(turn_context)
        results = await dialog_context.continue_dialog()
        if results.status == DialogTurnStatus.Empty:
            await dialog_context.begin_dialog(dialog.id)

Bots\DialogBot.cs

OnMessageActivityAsync 处理程序使用 RunAsync 方法来启动或继续对话。 OnTurnAsync 使用机器人的状态管理对象将所有状态更改保存到存储中。 ActivityHandler.OnTurnAsync 方法调用各种活动处理程序方法，例如 OnMessageActivityAsync。 这样，状态将在消息处理程序完成后和轮次本身完成前保存。

public override async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default)
{
    await base.OnTurnAsync(turnContext, cancellationToken);

    // Save any state changes that might have occurred during the turn.
    await ConversationState.SaveChangesAsync(turnContext, false, cancellationToken);
    await UserState.SaveChangesAsync(turnContext, false, cancellationToken);
}

protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    Logger.LogInformation("Running dialog with Message Activity.");

    // Run the Dialog with the new message Activity.
    await Dialog.RunAsync(turnContext, ConversationState.CreateProperty<DialogState>(nameof(DialogState)), cancellationToken);
}

onMessage 方法注册一个侦听器，该侦听器调用对话的 run 方法来启动或继续对话。

机器人单独重写 ActivityHandler.run 方法，以将聊天和用户状态保存到存储。 这样，状态将在消息处理程序完成后和轮次本身完成前保存。

bots/dialogBot.js

this.conversationState = conversationState;
this.userState = userState;
this.dialog = dialog;
this.dialogState = this.conversationState.createProperty('DialogState');

this.onMessage(async (context, next) => {
    console.log('Running dialog with Message Activity.');

        await next();
    });
}

/**
 * Override the ActivityHandler.run() method to save state changes after the bot logic completes.
 */
async run(context) {
    await super.run(context);

DialogBot.java

onMessageActivity 处理程序使用 run 方法来启动或继续对话。 onTurn 使用机器人的状态管理对象将所有状态更改保存到存储中。 ActivityHandler.onTurn 方法调用各种活动处理程序方法，例如 onMessageActivity。 这样，状态将在消息处理程序完成后和轮次本身完成前保存。

on_message_activity 处理程序使用帮助器方法来启动或继续对话。 on_turn 方法使用机器人的状态管理对象将所有状态更改保存到存储中。 在运行其他定义的处理程序（例如 on_message_activity）之后，最后会调用 on_turn 方法。 这样，状态将在消息处理程序完成后和轮次本身完成前保存。

bots\dialog_bot.py

async def on_turn(self, turn_context: TurnContext):
    await super().on_turn(turn_context)

    # Save any state changes that might have ocurred during the turn.
    await self.conversation_state.save_changes(turn_context)
    await self.user_state.save_changes(turn_context)

async def on_message_activity(self, turn_context: TurnContext):
    await DialogHelper.run_dialog(
        self.dialog,
        turn_context,
        self.conversation_state.create_property("DialogState"),
    )

Startup.cs

在 Startup 中注册机器人的服务。 可以通过依赖项注入将这些服务用于其他代码部分。

{
    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddHttpClient().AddControllers().AddNewtonsoftJson(options =>
        {
            options.SerializerSettings.MaxDepth = HttpHelper.BotMessageSerializerSettings.MaxDepth;
        });

        // Create the Bot Framework Authentication to be used with the Bot Adapter.
        services.AddSingleton<BotFrameworkAuthentication, ConfigurationBotFrameworkAuthentication>();

        // Create the Bot Adapter with error handling enabled.
        services.AddSingleton<IBotFrameworkHttpAdapter, AdapterWithErrorHandler>();

        // Create the storage we'll be using for User and Conversation state. (Memory is great for testing purposes.)
        services.AddSingleton<IStorage, MemoryStorage>();

        // Create the User state. (Used in this bot's Dialog implementation.)
        services.AddSingleton<UserState>();

        // Create the Conversation state. (Used by the Dialog system itself.)
        services.AddSingleton<ConversationState>();

index.js

在 index.js 中注册机器人的服务。

    // This check writes out errors to console log .vs. app insights.
    // NOTE: In production environment, you should consider logging this to Azure
    //       application insights. See https://aka.ms/bottelemetry for telemetry
    //       configuration instructions.
    console.error(`\n [onTurnError] unhandled error: ${ error }`);

    // Send a trace activity, which will be displayed in Bot Framework Emulator
    await context.sendTraceActivity(
        'OnTurnError Trace',
        `${ error }`,
        'https://www.botframework.com/schemas/error',
        'TurnError'
    );

    // Send a message to the user
    await context.sendActivity('The bot encountered an error or bug.');
    await context.sendActivity('To continue to run this bot, please fix the bot source code.');
    // Clear out state
    await conversationState.delete(context);
};

// Define the state store for your bot.
// See https://aka.ms/about-bot-state to learn more about using MemoryStorage.
// A bot requires a state storage system to persist the dialog and user state between messages.
const memoryStorage = new MemoryStorage();

// Create conversation state with in-memory storage provider.
const conversationState = new ConversationState(memoryStorage);
const userState = new UserState(memoryStorage);

// Create the main dialog.
const dialog = new UserProfileDialog(userState);
const bot = new DialogBot(conversationState, userState, dialog);

// Create HTTP server.
const server = restify.createServer();
server.use(restify.plugins.bodyParser());

server.listen(process.env.port || process.env.PORT || 3978, function() {

Application.java

Spring 通过依赖项注入提供 ConversationState、UserState 和 Dialog。 覆盖 getBot 并返回 DialogBot 的实例。

在 app.py 中注册机器人的服务。

# See https://aka.ms/about-bot-adapter to learn more about how bots work.
ADAPTER = CloudAdapter(ConfigurationBotFrameworkAuthentication(CONFIG))

# Catch-all for errors.
async def on_error(context: TurnContext, error: Exception):
    # This check writes out errors to console log
    # NOTE: In production environment, you should consider logging this to Azure
    #       application insights.
    print(f"\n [on_turn_error]: { error }", file=sys.stderr)
    traceback.print_exc()

    # Send a message to the user
    await context.send_activity("The bot encountered an error or bug.")
    await context.send_activity(
        "To continue to run this bot, please fix the bot source code."
    )
    # Send a trace activity if we're talking to the Bot Framework Emulator
    if context.activity.channel_id == "emulator":
        # Create a trace activity that contains the error object
        trace_activity = Activity(
            label="TurnError",
            name="on_turn_error Trace",
            timestamp=datetime.utcnow(),
            type=ActivityTypes.trace,
            value=f"{error}",
            value_type="https://www.botframework.com/schemas/error",
        )

        # Send a trace activity, which will be displayed in Bot Framework Emulator
        await context.send_activity(trace_activity)

    # Clear out state
    await CONVERSATION_STATE.delete(context)


# Set the error handler on the Adapter.
# In this case, we want an unbound method, so MethodType is not needed.
ADAPTER.on_turn_error = on_error

# Create MemoryStorage, UserState and ConversationState
MEMORY = MemoryStorage()
CONVERSATION_STATE = ConversationState(MEMORY)
USER_STATE = UserState(MEMORY)

# create main dialog and bot
DIALOG = UserProfileDialog(USER_STATE)
BOT = DialogBot(CONVERSATION_STATE, USER_STATE, DIALOG)


# Listen for incoming requests on /api/messages.

UserProfileDialog.cs

下面是 AgePromptValidatorAsync 方法定义的验证程序代码示例。 promptContext.Recognized.Value 包含已解析的值，此值是一个整数，用于数值提示。 promptContext.Recognized.Succeeded 指示提示是否能够解析用户的输入。 验证程序应返回 false 以指示未接受该值，且提示对话应重新提示用户；否则，返回 true 以指示接受输入并从提示对话返回。 可以根据方案更改验证程序中的值。

    }

    // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
    return await stepContext.PromptAsync(nameof(ConfirmPrompt), new PromptOptions { Prompt = MessageFactory.Text("Is this ok?") }, cancellationToken);
}

对话框\userProfileDialog.js

下面是 agePromptValidator 方法定义的验证程序代码示例。 promptContext.recognized.value 包含已解析的值，此值是一个整数，用于数值提示。 promptContext.recognized.succeeded 指示提示是否能够解析用户的输入。 验证程序应返回 false 以指示未接受该值，且提示对话应重新提示用户；否则，返回 true 以指示接受输入并从提示对话返回。 可以根据方案更改验证程序中的值。

    }
}

// WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is the end.

UserProfileDialog.java

下面是 agePromptValidator 方法定义的验证程序代码示例。 promptContext.getRecognized().getValue() 包含已解析的值，此值是一个整数，用于数值提示。 promptContext.getRecognized().getSucceeded() 指示提示是否能够解析用户的输入。 验证程序应返回 false 以指示它不接受该值。 提示对话应重新提示用户；否则，应返回 true 以接受输入，然后从提示对话返回。 可以根据方案更改验证程序中的值。

dialogs/user_profile_dialog.py

下面是 age_prompt_validator 方法定义的验证程序代码示例。 prompt_context.recognized.value 包含已解析的值，此值是一个整数，用于数值提示。 prompt_context.recognized.succeeded 指示提示是否能够解析用户的输入。 验证程序应返回 false 以指示未接受该值，且提示对话应重新提示用户；否则，返回 true 以指示接受输入并从提示对话返回。 可以根据方案更改验证程序中的值。

@staticmethod
async def age_prompt_validator(prompt_context: PromptValidatorContext) -> bool:
    # This condition is our validation rule. You can also change the value at this point.
    return (
        prompt_context.recognized.succeeded