Gestire la complessità dei dialoghi

Per usare i dialoghi, installare il pacchetto NuGet Microsoft.Bot.Builder.Dialogs.

Dialogs\UserProfileDialog.cs

In questo caso la classe UserProfileDialog deriva dalla classe ComponentDialog.

public class UserProfileDialog : ComponentDialog

All'interno del costruttore il metodo AddDialog aggiunge dialoghi e richieste al dialogo componente. Il primo elemento aggiunto con questo metodo viene impostato come finestra di dialogo iniziale. È possibile modificare la finestra di dialogo iniziale impostando in modo esplicito la InitialDialogId proprietà . Quando si avvia un dialogo componenti, viene avviato il relativo dialogo iniziale.

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);
}

Il codice seguente rappresenta il primo passaggio del dialogo a cascata.

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);
}

Per altre informazioni sull'implementazione dei dialoghi a cascata, vedere come implementare un flusso di conversazione sequenziale.

Per usare i dialoghi, è necessario installare il pacchetto npm botbuilder-dialogs per il progetto.

dialogs/userProfileDialog.js

In questo caso la classe UserProfileDialog estende ComponentDialog.

class UserProfileDialog extends ComponentDialog {

All'interno del costruttore il metodo AddDialog aggiunge dialoghi e richieste al dialogo componente. Il primo elemento aggiunto con questo metodo viene impostato come finestra di dialogo iniziale. È possibile modificare la finestra di dialogo iniziale impostando in modo esplicito la InitialDialogId proprietà . Quando si avvia un dialogo componenti, viene avviato il relativo dialogo iniziale.

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)
    ]));

    this.initialDialogId = WATERFALL_DIALOG;
}

Il codice seguente rappresenta il primo passaggio del dialogo a cascata.

async transportStep(step) {
    // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
    // Running a prompt here means the next WaterfallStep will be run when the user's response is received.
    return await step.prompt(CHOICE_PROMPT, {
        prompt: 'Please enter your mode of transport.',
        choices: ChoiceFactory.toChoices(['Car', 'Bus', 'Bicycle'])
    });
}

Per altre informazioni sull'implementazione dei dialoghi a cascata, vedere come implementare un flusso di conversazione sequenziale.

UserProfileDialog.java

In questo caso la classe UserProfileDialog deriva dalla classe ComponentDialog.

public class UserProfileDialog extends ComponentDialog {

All'interno del costruttore il metodo addDialog aggiunge dialoghi e richieste al dialogo componente. Il primo elemento aggiunto con questo metodo viene impostato come finestra di dialogo iniziale. È possibile modificare il dialogo iniziale chiamando il setInitialDialogId metodo e specificando il nome del dialogo iniziale. Quando si avvia un dialogo componenti, viene avviato il relativo dialogo iniziale.

public UserProfileDialog(UserState withUserState) {
    super("UserProfileDialog");

    userProfileAccessor = withUserState.createProperty("UserProfile");

    WaterfallStep[] waterfallSteps = {
        UserProfileDialog::transportStep,
        UserProfileDialog::nameStep,
        this::nameConfirmStep,
        this::ageStep,
        UserProfileDialog::pictureStep,
        this::confirmStep,
        this::summaryStep
    };

    // Add named dialogs to the DialogSet. These names are saved in the dialog state.
    addDialog(new WaterfallDialog("WaterfallDialog", Arrays.asList(waterfallSteps)));
    addDialog(new TextPrompt("TextPrompt"));
    addDialog(new NumberPrompt<Integer>("NumberPrompt", UserProfileDialog::agePromptValidator, Integer.class));
    addDialog(new ChoicePrompt("ChoicePrompt"));
    addDialog(new ConfirmPrompt("ConfirmPrompt"));
    addDialog(new AttachmentPrompt("AttachmentPrompt", UserProfileDialog::picturePromptValidator));

    // The initial child Dialog to run.
    setInitialDialogId("WaterfallDialog");
}

Il codice seguente rappresenta il primo passaggio del dialogo a cascata.

private static CompletableFuture<DialogTurnResult> nameStep(WaterfallStepContext stepContext) {
    stepContext.getValues().put("transport", ((FoundChoice) stepContext.getResult()).getValue());

    PromptOptions promptOptions = new PromptOptions();
    promptOptions.setPrompt(MessageFactory.text("Please enter your name."));
    return stepContext.prompt("TextPrompt", promptOptions);
}

Per altre informazioni sull'implementazione dei dialoghi a cascata, vedere come implementare un flusso di conversazione sequenziale.

Per usare i dialoghi, installare i pacchetti PyPI botbuilder-dialogs e botbuilder-ai eseguendo pip install botbuilder-dialogs e pip install botbuilder-ai in un terminale.

dialogs/user_profile_dialog.py

In questo caso la classe UserProfileDialog estende ComponentDialog.

class UserProfileDialog(ComponentDialog):

All'interno del costruttore il metodo add_dialog aggiunge dialoghi e richieste al dialogo componente. Il primo elemento aggiunto con questo metodo viene impostato come finestra di dialogo iniziale. È possibile modificare la finestra di dialogo iniziale impostando in modo esplicito la initial_dialog_id proprietà . Quando si avvia un dialogo componenti, viene avviato il relativo dialogo iniziale.

class UserProfileDialog(ComponentDialog):
    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__

Il codice seguente rappresenta il primo passaggio del dialogo a cascata.

async def transport_step(
    self, step_context: WaterfallStepContext
) -> DialogTurnResult:
    # WaterfallStep always finishes with the end of the Waterfall or with another dialog;
    # here it is a Prompt Dialog. Running a prompt here means the next WaterfallStep will
    # be run when the users response is received.
    return await step_context.prompt(
        ChoicePrompt.__name__,
        PromptOptions(
            prompt=MessageFactory.text("Please enter your mode of transport."),
            choices=[Choice("Car"), Choice("Bus"), Choice("Bicycle")],
        ),
    )

Per altre informazioni sull'implementazione dei dialoghi a cascata, vedere come implementare un flusso di conversazione sequenziale.

Bots\DialogBot.cs

Nell'esempio questa operazione viene eseguita usando il metodo RunAsync che viene chiamato dal metodo OnMessageActivityAsync del bot.

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);
}

dialogs/userProfileDialog.js

Nell'esempio è stato aggiunto un metodo run nel dialogo del profilo utente.

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);
    }
}

bots/dialogBot.js

Il metodo run viene chiamato dal metodo onMessage del bot.

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

    // Run the Dialog with the new message Activity.
    await this.dialog.run(context, this.dialogState);

    await next();
});

DialogBot.java

Nell'esempio questa operazione viene eseguita usando il metodo run che viene chiamato dal metodo onMessageActivity del bot.

@Override
protected CompletableFuture<Void> onMessageActivity(
    TurnContext turnContext
) {
    LoggerFactory.getLogger(DialogBot.class).info("Running dialog with Message Activity.");

    // Run the Dialog with the new message Activity.
    return Dialog.run(dialog, turnContext, conversationState.createProperty("DialogState"));
}

helpers/dialog_helper.py

Nell'esempio è stato aggiunto un metodo run_dialog nel dialogo del profilo utente.

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)

Il metodo run_dialog chiamato dal metodo on_message_activity del bot.

bots/dialog_bot.py

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