Správa složitosti dialogů

PLATÍ PRO: SDK v4

V dialogových oknech komponent můžete vytvořit nezávislá dialogová okna pro zpracování konkrétních scénářů a rozdělit velké dialogové okno na lépe spravovatelné části. Každá z těchto částí má vlastní sadu dialogových oken a zabraňuje kolizím názvů s dialogovými sadami mimo ni. Dialogy komponent jsou opakovaně použitelné v tom, že můžou být:

• Přidáno do jiného ComponentDialog nebo DialogSet do robota.
• Exportován jako součást balíčku.
• Používá se v jiných robotech.

Poznámka:

Sady SDK služby Bot Framework JavaScript, C# a Python budou nadále podporovány, ale sada Java SDK se vyřazuje s konečnou dlouhodobou podporou končící v listopadu 2023.

Stávající roboti sestavení pomocí sady Java SDK budou i nadále fungovat.

Pro nové vytváření robotů zvažte použití Power Virtual Agents a přečtěte si o výběru správného řešení chatovacího robota.

Další informace najdete v tématu Budoucnost vytváření robotů.

Požadavky

• Znalost základů robotů, knihovny dialogových oken a správy konverzací
• Kopie ukázky vícenásobných výzev v jazyce C#, JavaScript, Java nebo Python.

Informace o ukázce

V ukázce vícenásobných výzev použijeme vodopádový dialog, několik výzev a dialogové okno komponent k vytvoření interakce, která uživatele zeptá na řadu otázek. Kód pomocí dialogového okna prochází těmito kroky:

Kroky	Typ výzvy
Požádejte uživatele o způsob dopravy.	Výzva k volbě
Požádejte uživatele o své jméno.	Výzva k zadání textu
Zeptejte se uživatele, jestli chce poskytnout svůj věk.	Potvrdit výzvu
Pokud odpověděli ano, požádejte o svůj věk.	Výzva k zadání čísla s ověřením, aby přijímala pouze věky větší než 0 a menší než 150.
Zeptejte se, jestli jsou shromážděné informace "ok".	Znovu použít výzvu k potvrzení

A konečně, pokud odpověděli ano, zobrazte shromážděné informace; jinak dejte uživateli vědět, že se jejich informace neuchovávají.

Dialogové okno Implementace komponenty

V ukázce vícenásobných výzev použijeme vodopádový dialog, několik výzev a dialogové okno komponent k vytvoření interakce, která uživatele zeptá na řadu otázek.

Dialogové okno komponenty zapouzdřuje jedno nebo více dialogů. Dialogové okno komponenty obsahuje vnitřní sadu dialogových oken a dialogová okna a výzvy, které přidáte do této vnitřní sady dialogů, mají vlastní ID, která jsou viditelná pouze v dialogovém okně komponenty.

C#

Pokud chcete použít dialogy, nainstalujte balíček NuGet Microsoft.Bot.Builder.Dialogs .

Dialogy\UserProfileDialog.cs

Zde třída UserProfileDialog je odvozena od ComponentDialog třídy.

public class UserProfileDialog : ComponentDialog

V konstruktoru AddDialog metoda přidá dialogy a zobrazí výzvu k dialogovému okně komponenty. První položka, kterou přidáte pomocí této metody, je nastavena jako počáteční dialogové okno. Počáteční dialogové okno můžete změnit explicitním nastavením InitialDialogId vlastnosti. Když spustíte dialogové okno komponenty, spustí se jeho počáteční dialogové okno.

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

Následující kód představuje první krok vodopádového dialogového okna.

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

Další informace o implementaci vodopádových dialogových oken najdete v tématu implementace sekvenčního toku konverzace.

JavaScript

Pokud chcete použít dialogy, musí váš projekt nainstalovat balíček npm botbuilder-dialogs .

dialogy/userProfileDialog.js

UserProfileDialog Zde třída rozšiřuje ComponentDialog.

class UserProfileDialog extends ComponentDialog {

V konstruktoru AddDialog metoda přidá dialogy a zobrazí výzvu k dialogovému okně komponenty. První položka, kterou přidáte pomocí této metody, je nastavena jako počáteční dialogové okno. Počáteční dialogové okno můžete změnit explicitním nastavením InitialDialogId vlastnosti. Když spustíte dialogové okno komponenty, spustí se jeho počáteční dialogové okno.

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

Následující kód představuje první krok vodopádového dialogového okna.

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

Další informace o implementaci vodopádových dialogových oken najdete v tématu implementace sekvenčního toku konverzace.

Java

UserProfileDialog.java

Zde třída UserProfileDialog je odvozena od ComponentDialog třídy.

public class UserProfileDialog extends ComponentDialog {

V konstruktoru addDialog metoda přidá dialogy a zobrazí výzvu k dialogovému okně komponenty. První položka, kterou přidáte pomocí této metody, je nastavena jako počáteční dialogové okno. Počáteční dialogové okno můžete změnit voláním setInitialDialogId metody a zadáním názvu počátečního dialogového okna. Když spustíte dialogové okno komponenty, spustí se jeho počáteční dialogové okno.

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

Následující kód představuje první krok vodopádového dialogového okna.

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

Další informace o implementaci vodopádových dialogových oken najdete v tématu implementace sekvenčního toku konverzace.

Python

Pokud chcete používat dialogy, nainstalujte balíčky botbuilder-dialogy a botbuilder-aiPyPI spuštěním pip install botbuilder-dialogs a pip install botbuilder-ai z terminálu.

dialogy/user_profile_dialog.py

UserProfileDialog Zde třída rozšiřuje ComponentDialog.

class UserProfileDialog(ComponentDialog):

V konstruktoru add_dialog metoda přidá dialogy a zobrazí výzvu k dialogovému okně komponenty. První položka, kterou přidáte pomocí této metody, je nastavena jako počáteční dialogové okno. Počáteční dialogové okno můžete změnit explicitním nastavením initial_dialog_id vlastnosti. Když spustíte dialogové okno komponenty, spustí se jeho počáteční dialogové okno.

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__

Následující kód představuje první krok vodopádového dialogového okna.

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")],
        ),
    )

Další informace o implementaci vodopádových dialogových oken najdete v tématu implementace sekvenčního toku konverzace.

V době běhu dialogové okno komponenty udržuje vlastní sadu dialogových oken. Po spuštění dialogového okna komponenty:

• Vytvoří se instance a přidá se do vnějšího zásobníku dialogových oken.
• Vytvoří vnitřní zásobník dialogů, který se přidá do jeho stavu.
• Spustí počáteční dialogové okno a přidá ho do vnitřního zásobníku dialogových oken.

Nadřazený kontext vidí komponentu jako aktivní dialogové okno. Kontext uvnitř komponenty však vypadá, že počáteční dialogové okno je aktivní dialogové okno.

Volání dialogového okna z robota

Ve vnější sadě dialogového okna, do kterého jste přidali dialogové okno komponenty, má dialogové okno komponenty ID, se kterým jste ho vytvořili. Ve vnější sadě komponenta vypadá jako jeden dialog, podobně jako výzvy.

Pokud chcete použít dialogové okno komponenty, přidejte jeho instanci do sady dialogových oken robota.

C#

Roboti\DialogBot.cs

V ukázce se to provádí pomocí RunAsync metody volané z metody robota OnMessageActivityAsync .

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

JavaScript

dialogy/userProfileDialog.js

V ukázce jsme do dialogového okna profilu uživatele přidali run metodu.

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

roboti/dialogBot.js

Metoda run se volá z metody robota onMessage .

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

Java

DialogBot.java

V ukázce se to provádí pomocí run metody volané z metody robota onMessageActivity .

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

Python

pomocné rutiny/dialog_helper.py

V ukázce jsme do dialogového okna profilu uživatele přidali run_dialog metodu.

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)

Metoda run_dialog , která se volá z metody robota on_message_activity .

roboti/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"),
    )

Otestovat robota

1. Pokud jste to ještě neudělali, nainstalujte bot Framework Emulator.
2. Spusťte ukázku místně na svém počítači.
3. Spusťte emulátor, připojte se k robotovi a odešlete zprávy, jak je znázorněno níže.

Další informace

Jak funguje zrušení v dialogových oknech komponent

Pokud voláte zrušení všech dialogových oken z kontextu dialogového okna komponenty, dialogové okno komponenty zruší všechna dialogová okna ve svém vnitřním zásobníku a pak ukončí a vrátí ovládací prvek do dalšího dialogového okna na vnějším zásobníku.

Pokud voláte zrušit všechna dialogová okna z vnějšího kontextu, komponenta se zruší spolu se zbývajícími dialogy na vnějším kontextu.

Další kroky

Naučte se vytvářet složité konverzace ve větvi a smyčce.

Zpracování přerušení uživatele