Verwenden eines Dialogs zum Nutzen eines SkillsUse a dialog to consume a skill

gilt für: SDK v4APPLIES TO: SDK v4

In diesem Artikel wird veranschaulicht, wie Sie einen Skilldialog innerhalb eines Skillconsumers verwenden.This article demonstrates how to use a skill dialog within a skill consumer. Der Skilldialog veröffentlicht Aktivitäten des übergeordneten Bots für den Skillbot und gibt die Skillantworten an den Benutzer zurück.The skill dialog posts activities from the parent bot to the skill bot and returns the skill responses to the user. Der von diesem Consumer verwendete Skillbot kann sowohl Nachrichten- als auch Ereignisaktivitäten verarbeiten.The skill bot accessed by this consumer can handle both message and event activities. Ein Beispiel für ein Skillmanifest und Informationen zur Implementierung des Skills finden Sie unter Verwenden von Dialogen in einem Skill.For a sample skill manifest and information about implementing the skill, see how to use dialogs within a skill.

Weitere Informationen zur Verwendung eines Skillbots außerhalb von Dialogen finden Sie unter Implementieren eines Skillconsumers.For information about using a skill bot outside of dialogs, see how to implement a skill consumer.

VoraussetzungenPrerequisites

Hinweis

Ab Version 4,11 benötigen Sie keine APP-ID und kein Kennwort, um einen Fähigkeits Consumer lokal im Emulator zu testen.Starting with version 4.11, you do not need an app ID and password to test a skill consumer locally in the Emulator. Es ist immer noch ein Azure-Abonnement erforderlich, um Ihren Consumer in Azure bereitzustellen oder um eine bereitgestellte Qualifikation zu nutzen.An Azure subscription is still required to deploy your consumer to Azure or to consume a deployed skill.

Informationen zu diesem BeispielAbout this sample

Das Skillbeispiel skillDialog enthält Projekte für zwei Bots:The skills skillDialog sample includes projects for two bots:

  • dialog root bot, in dem mit einer skillDialog-Klasse ein Skill genutzt wird.The dialog root bot, which uses a skill dialog class to consume a skill.
  • dialog skill bot, in dem mit einem Dialog von Skillconsumern stammende Aktivitäten behandelt werden.The dialog skill bot, which uses a dialog to handle activities coming from skill consumers.

In diesem Artikel geht es um die Verwendung einer skillDialog-Klasse in einem Stammbot zum Verwalten des Skills, zum Senden von Nachrichten- und Ereignisaktivitäten und zum Abbrechen des Skills.This article focuses on how to use a skill dialog class in a root bot to manage the skill, to send message and event activities and to cancel the skill.

Weitere Informationen zu anderen Aspekten der Erstellung eines Skillconsumers finden Sie unter Implementieren eines Skillconsumers.For information about other aspects of creating a skill consumer, see how to implement a skill consumer.

Weitere Informationen zum Dialogskillbot finden Sie unter Verwenden von Dialogen in einem Skill.For information about the dialog skill bot, see how to use dialogs within a skill.

RessourcenResources

Für bereitgestellte Bots erfordert die bot-zu-bot-Authentifizierung, dass jeder teilnehmende bot über eine gültige APP-ID und ein gültiges Kennwort verfügt.For deployed bots, bot-to-bot authentication requires that each participating bot has a valid app ID and password. Allerdings können Sie die Fähigkeiten und Fertigkeiten der Consumer lokal mit dem Emulator ohne APP-ID und Kennwort testen.However, you can test skills and skill consumers locally with the Emulator without an app ID and password.

AnwendungskonfigurationApplication configuration

  1. Optional können Sie die APP-ID und das Kennwort des stammbots der Konfigurationsdatei hinzufügen.Optionally, add the root bot's app ID and password to the config file.
  2. Fügen Sie den Skills Host-Endpunkt (den Dienst oder die Rückruf-URL) hinzu, dem die Fähigkeiten an den Skills-Consumer antworten sollen.Add the skill host endpoint (the service or callback URL) to which the skills should reply to the skill consumer.
  3. Fügen Sie einen Eintrag für jede Qualifikation hinzu, die vom Skill-Consumer verwendet wird.Add an entry for each skill the skill consumer will use. Jeder Eintrag umfasst Folgendes:Each entry includes:
    • Eine ID, die vom Skill-Consumer verwendet wird, um die einzelnen Qualifikationen zu identifizieren.An ID the skill consumer will use to identify each skill.
    • Optional: die APP-ID der Qualifikation.Optionally, the skill's app ID.
    • Den Messagingendpunkt der Qualifikation.The skill's messaging endpoint.

Hinweis

Wenn der Consumer der Qualifikation eine APP-ID und ein Kennwort verwendet, muss beides.If either the skill or skill consumer uses an app ID and password, both must.

DialogRootBot\appsettings.jsonDialogRootBot\appsettings.json

Fügen Sie optional die APP-ID und das Kennwort des stammbot hinzu, und fügen Sie dem Array die APP-ID für den Echo-Fähigkeits bot hinzu BotFrameworkSkills .Optionally, add the root bot's app ID and password and add the app ID for the echo skill bot to the BotFrameworkSkills array.

{
  "MicrosoftAppId": "TODO: Add here the App ID for the bot",
  "MicrosoftAppPassword": "TODO: Add here the password for the bot",

  "SkillHostEndpoint": "http://localhost:3978/api/skills/",
  "BotFrameworkSkills": [
    {
      "Id": "DialogSkillBot",
      "AppId": "TODO: Add here the App ID for the skill",
      "SkillEndpoint": "http://localhost:39783/api/messages"
    }
  ]
}

DialoglogikDialog logic

Der Hauptdialog des Bots enthält einen Skilldialog für jeden Skill, den dieser Bot verwendet.The bot's main dialog includes a skill dialog for each skill this bot consumes. Mit dem Skilldialog wird der Skill in den verschiedenen skillbezogenen Objekten für Sie verwaltet. Dazu gehören z. B. der Skillclient und die Objekte der Skillkonversations-ID-Factory.The skill dialog manages the skill through the various skill-related objects for you, such as the skill client and the skill conversation ID factory objects. Außerdem veranschaulicht der Hauptdialog, wie Sie den Skill (über den Skilldialog) basierend auf Benutzereingaben abbrechen.The main dialog also demonstrates how to cancel the skill (through the skill dialog) based on user input.

Der Skill, den dieser Bot verwendet, unterstützt verschiedene Features.The skill this bot uses supports a couple different features. Er kann einen Flug buchen oder das Wetter in einer Stadt abfragen.It can book a flight or get the weather for a city. Wenn er darüber hinaus eine Nachricht außerhalb eines dieser Kontexte empfängt und eine LUIS-Erkennung konfiguriert ist, versucht er, die Absicht des Benutzers zu interpretieren.In addition, if it receives a message outside either of these contexts and a LUIS recognizer is configured, it attempts to interpret the user's intent.

Im Skillmanifest (C#, JavaScript, Python) werden die ausführbaren Aktionen, die Ein- und Ausgabeparameter und die Endpunkte des Skills beschrieben.The skill manifest (C#, JavaScript, Python) describes the actions the skill can perform, its input and output parameters, and the skill's endpoints. Beachten Sie, dass der Skill die Ereignisse „BookFlight“ und „GetWeather“ verarbeiten kann.Of note, the skill can handle a "BookFlight" or "GetWeather" event. Er kann auch Nachrichten verarbeiten.It can also handle messages.

Der Hauptdialog enthält Code für Folgendes:The main dialog includes code to:

Der Hauptdialog erbt von der Klasse für Komponentendialoge.The main dialog inherits from the component dialog class. Weitere Informationen zu Komponentendialogen finden Sie unter Verwalten der Dialogkomplexität.For more about component dialogs, see how to manage dialog complexity.

Initialisieren des HauptdialogsInitialize the main dialog

Der Hauptdialog umfasst Dialoge (zum Verwalten des Konversationsflows außerhalb des Skills) und einen Skilldialog (zur Verwaltung der Skills).The main dialog includes dialogs (for managing conversation flow outside the skill) and a skill dialogs (for managing the skills). Der Wasserfalldialog umfasst die folgenden Schritte, die in den nächsten Abschnitten ausführlicher beschrieben werden.The waterfall includes the following steps, described in more detail in the next few sections.

  1. Auffordern des Benutzers zur Auswahl des zu verwendenden SkillsPrompt the user to select the skill to use. (Der Stammbot nutzt einen Skill.)(The root bot consumes 1 skill.)
  2. Auffordern des Benutzers zur Auswahl der für diesen Skill zu verwendenden AktionPrompt the user to select the action to use for that skill. (Der Skillbot definiert drei Aktionen.)(The skill bot defines 3 actions.)
  3. Starten des ausgewählten Skills mit einer anfänglichen Aktivität basierend auf der ausgewählten AktionStart the chosen skill with an initial activity based on the chosen action.
  4. Nach Abschluss des Skills: Anzeigen der Ergebnisse (sofern vorhanden).Once the skill completes, display the results, if any. Anschließend wird der Wasserfalldialog erneut gestartet.Then, restart the waterfall.

DialogRootBot\Dialogs\MainDialog.csDialogRootBot\Dialogs\MainDialog.cs

Die MainDialog-Klasse wird von ComponentDialog abgeleitet.The MainDialog class derives from ComponentDialog. Neben dem Konversationszustand benötigt der Dialog die App-ID des Stammbots sowie Verweise auf die Skillkonversations-ID-Factory, den Skills-HTTP-Client und die Skillkonfigurationsobjekte.In addition to conversation state, the dialog needs the root bot's app ID and references to the skill conversation ID factory, the skill HTTP client, and the skills configuration objects.

Der Dialogkonstruktor überprüft seine Eingabeparameter, fügt Skilldialoge sowie Eingabeaufforderungs- und Wasserfalldialoge zum Verwalten des Konversationsflows außerhalb des Skills hinzu und erstellt einen Eigenschaften-Accessor zum Nachverfolgen des aktiven Skills (sofern vorhanden).The dialog constructor checks its input parameters, adds skills dialogs, adds prompt and a waterfall dialogs for managing conversation flow outside the skill, and creates a property accessor for tracking the active skill, if any.

Der Konstruktor ruft die Hilfsmethode AddSkillDialogs auf, um für jeden Skill in der Konfigurationsdatei einen SkillDialog zu erstellen. Dies erfolgt während des Einlesens der Konfigurationsdatei in ein SkillsConfiguration-Objekt.The constructor calls AddSkillDialogs, a helper method, to create a SkillDialog for each skill that is included in the configuration file, as read from the configuration file into a SkillsConfiguration object.

// Helper method that creates and adds SkillDialog instances for the configured skills.
private void AddSkillDialogs(ConversationState conversationState, SkillConversationIdFactoryBase conversationIdFactory, SkillHttpClient skillClient, SkillsConfiguration skillsConfig, string botId)
{
    foreach (var skillInfo in _skillsConfig.Skills.Values)
    {
        // Create the dialog options.
        var skillDialogOptions = new SkillDialogOptions
        {
            BotId = botId,
            ConversationIdFactory = conversationIdFactory,
            SkillClient = skillClient,
            SkillHostEndpoint = skillsConfig.SkillHostEndpoint,
            ConversationState = conversationState,
            Skill = skillInfo
        };

        // Add a SkillDialog for the selected skill.
        AddDialog(new SkillDialog(skillDialogOptions, skillInfo.Id));
    }
}

Auswählen eines SkillsSelect a skill

Im ersten Schritt wird der Benutzer im Hauptdialog aufgefordert, den aufzurufenden Skill anzugeben. Dabei wird die SkllPrompt-Option verwendet, um die Antwort zu erhalten.In its first step, the main dialog prompts the user for which skill they'd like to call, and uses the "SkllPrompt" choice prompt to get the answer. (Dieser Bot definiert nur einen Skill.)(This bot defines only one skill.)

DialogRootBot\Dialogs\MainDialog.csDialogRootBot\Dialogs\MainDialog.cs

// Render a prompt to select the skill to call.
private async Task<DialogTurnResult> SelectSkillStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    // Create the PromptOptions from the skill configuration which contain the list of configured skills.
    var messageText = stepContext.Options?.ToString() ?? "What skill would you like to call?";
    var repromptMessageText = "That was not a valid choice, please select a valid skill.";
    var options = new PromptOptions
    {
        Prompt = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput),
        RetryPrompt = MessageFactory.Text(repromptMessageText, repromptMessageText, InputHints.ExpectingInput),
        Choices = _skillsConfig.Skills.Select(skill => new Choice(skill.Value.Id)).ToList()
    };

    // Prompt the user to select a skill.
    return await stepContext.PromptAsync("SkillPrompt", options, cancellationToken);
}

Auswählen einer SkillaktionSelect a skill action

Im nächsten Schritt führt der Hauptdialog Folgendes aus:In the next step, the main dialog:

  1. Speichern der Informationen zum Skill, den der Benutzer ausgewählt hatSaves information about the skill the user selected.
  2. Auffordern des Benutzer zur Auswahl des gewünschten Skills und Verwenden der SkillActionPrompt-Option zum Empfangen der AntwortPrompts the user for which skill action they'd like to use, and uses the "SkillActionPrompt" choice prompt to get the answer.
    • Mithilfe einer Hilfsmethode wird eine Liste von Aktionen abgerufen, die zur Auswahl bereitstehenIt uses a helper method to get a list of actions to choose from.
    • Das dieser Eingabeaufforderung zugeordnete Validierungssteuerelement sendet standardmäßig eine Nachricht an den Skill, wenn die Benutzereingabe nicht mit einer der Optionen übereinstimmt.The prompt validator associated with this prompt will default to sending the skill a message if the user's input doesn't match one of the choices.

Die in diesem Bot enthaltenen Optionen helfen dabei, die für diesen Skill definierten Aktionen zu testen.The choices included in this bot help test the actions defined for this skill. In der Regel würden Sie die Optionen aus dem Skillmanifest lesen und dem Benutzer basierend auf dieser Liste präsentieren.More typically, you would read the options from the skill's manifest, and present options to the user based on that list.

DialogRootBot\Dialogs\MainDialog.csDialogRootBot\Dialogs\MainDialog.cs

// Render a prompt to select the action for the skill.
private async Task<DialogTurnResult> SelectSkillActionStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    // Get the skill info based on the selected skill.
    var selectedSkillId = ((FoundChoice)stepContext.Result).Value;
    var selectedSkill = _skillsConfig.Skills.FirstOrDefault(s => s.Value.Id == selectedSkillId).Value;

    // Remember the skill selected by the user.
    stepContext.Values[_selectedSkillKey] = selectedSkill;

    // Create the PromptOptions with the actions supported by the selected skill.
    var messageText = $"Select an action # to send to **{selectedSkill.Id}** or just type in a message and it will be forwarded to the skill";
    var options = new PromptOptions
    {
        Prompt = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput),
        Choices = GetSkillActions(selectedSkill)
    };

    // Prompt the user to select a skill action.
    return await stepContext.PromptAsync("SkillActionPrompt", options, cancellationToken);
}
// Helper method to create Choice elements for the actions supported by the skill.
private IList<Choice> GetSkillActions(BotFrameworkSkill skill)
{
    // Note: the bot would probably render this by reading the skill manifest.
    // We are just using hardcoded skill actions here for simplicity.

    var choices = new List<Choice>();
    switch (skill.Id)
    {
        case "DialogSkillBot":
            choices.Add(new Choice(SkillActionBookFlight));
            choices.Add(new Choice(SkillActionBookFlightWithInputParameters));
            choices.Add(new Choice(SkillActionGetWeather));
            break;
    }

    return choices;
}
// This validator defaults to Message if the user doesn't select an existing option.
private Task<bool> SkillActionPromptValidator(PromptValidatorContext<FoundChoice> promptContext, CancellationToken cancellationToken)
{
    if (!promptContext.Recognized.Succeeded)
    {
        // Assume the user wants to send a message if an item in the list is not selected.
        promptContext.Recognized.Value = new FoundChoice { Value = SkillActionMessage };
    }

    return Task.FromResult(true);
}

Starten eines SkillsStart a skill

Im nächsten Schritt führt der Hauptdialog Folgendes aus:In the next step, the main dialog:

  1. Abrufen von Informationen zu dem Skill und der Skillaktivität, die der Benutzer ausgewählt hatRetrieves information about the skill and skill activity the user selected.
  2. Verwenden einer Hilfsmethode zum Erstellen der Aktivität, die als Erstes an den Skill gesendet wirdUses a helper method to create the activity to initially send to the skill.
  3. Erstellen der Dialogoptionen, mit denen der Skilldialog gestartet werden soll.Creates the dialog options with which to start the skill dialog. Dies schließt die Aktivität ein, die als Erstes gesendet werden soll.This includes the initial activity to send.
  4. Speichern des Zustands vor dem Aufrufen des SkillsSaves state before calling the skill. (Dies ist erforderlich, da die Antwort vom Skill möglicherweise an eine andere Instanz des Skillconsumers erfolgt.)(This is necessary, as the skill response might come to a different instance of the skill consumer.)
  5. Starten des Skilldialogs und Übergeben der aufzurufenden Skill-ID und der Optionen für den AufrufBegins the skill dialog, passing in the skill ID to call and the options with which to call it.

DialogRootBot\Dialogs\MainDialog.csDialogRootBot\Dialogs\MainDialog.cs

// Starts the SkillDialog based on the user's selections.
private async Task<DialogTurnResult> CallSkillActionStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    var selectedSkill = (BotFrameworkSkill)stepContext.Values[_selectedSkillKey];

    Activity skillActivity;
    switch (selectedSkill.Id)
    {
        case "DialogSkillBot":
            skillActivity = CreateDialogSkillBotActivity(((FoundChoice)stepContext.Result).Value, stepContext.Context);
            break;

        // We can add other case statements here if we support more than one skill.
        default:
            throw new Exception($"Unknown target skill id: {selectedSkill.Id}.");
    }

    // Create the BeginSkillDialogOptions and assign the activity to send.
    var skillDialogArgs = new BeginSkillDialogOptions { Activity = skillActivity };

    // Save active skill in state.
    await _activeSkillProperty.SetAsync(stepContext.Context, selectedSkill, cancellationToken);

    // Start the skillDialog instance with the arguments. 
    return await stepContext.BeginDialogAsync(selectedSkill.Id, skillDialogArgs, cancellationToken);
}

Zusammenfassen der SkillergebnisseSummarize the skill result

Im letzten Schritt führt der Hauptdialog Folgendes aus:In the last step, the main dialog:

  1. Anzeigen des Ergebnisses für den Benutzer (sofern der Skill einen Wert zurückgegeben hat)If the skill returned a value, display the result to the user.
  2. Löschen des aktiven Skills aus dem DialogzustandClears the active skill from dialog state.
  3. Entfernen der Eigenschaft des aktiven Skills aus dem KonversationszustandRemoves the active skill property from conversation state.
  4. Ausführen eines eigenen Neustarts (der Hauptdialog)Restarts itself (the main dialog).

DialogRootBot\Dialogs\MainDialog.csDialogRootBot\Dialogs\MainDialog.cs

// The SkillDialog has ended, render the results (if any) and restart MainDialog.
private async Task<DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    var activeSkill = await _activeSkillProperty.GetAsync(stepContext.Context, () => null, cancellationToken);

    // Check if the skill returned any results and display them.
    if (stepContext.Result != null)
    {
        var message = $"Skill \"{activeSkill.Id}\" invocation complete.";
        message += $" Result: {JsonConvert.SerializeObject(stepContext.Result)}";
        await stepContext.Context.SendActivityAsync(MessageFactory.Text(message, message, inputHint: InputHints.IgnoringInput), cancellationToken: cancellationToken);
    }

    // Clear the skill selected by the user.
    stepContext.Values[_selectedSkillKey] = null;

    // Clear active skill in state.
    await _activeSkillProperty.DeleteAsync(stepContext.Context, cancellationToken);

    // Restart the main dialog with a different message the second time around.
    return await stepContext.ReplaceDialogAsync(InitialDialogId, $"Done with \"{activeSkill.Id}\". \n\n What skill would you like to call?", cancellationToken);
}

Ermöglichen des Skillabbruchs durch den BenutzerAllow the user to cancel the skill

Im Hauptdialog wird das Standardverhalten der on continue dialog-Methode überschrieben, damit der Benutzer den aktuellen Skill ggf. abbrechen kann.The main dialog overrides the default behavior of the on continue dialog method to allow the user to cancel the current skill, if any. Die Methode führt Folgendes aus:The method:

  • Wenn ein aktiver Skill vorhanden ist und der Benutzer eine Abbruchmeldung („abort“) sendet: Abbrechen sämtlicher Dialoge und Einreihen des Hauptdialogs in die Warteschlange für den NeustartIf there is an active skill and the user sends an "abort" message, cancel all dialogs and queue the main dialog to restart from the beginning.
  • Anschließend: Aufrufen der Basisimplementierung der on continue dialog-Methode, um die Verarbeitung des aktuellen Durchlaufs fortzusetzenThen, call the base implementation of the on continue dialog method to continue processing the current turn.

DialogRootBot\Dialogs\MainDialog.csDialogRootBot\Dialogs\MainDialog.cs

protected override async Task<DialogTurnResult> OnContinueDialogAsync(DialogContext innerDc, CancellationToken cancellationToken = default)
{
    // This is an example on how to cancel a SkillDialog that is currently in progress from the parent bot.
    var activeSkill = await _activeSkillProperty.GetAsync(innerDc.Context, () => null, cancellationToken);
    var activity = innerDc.Context.Activity;
    if (activeSkill != null && activity.Type == ActivityTypes.Message && activity.Text.Equals("abort", StringComparison.CurrentCultureIgnoreCase))
    {
        // Cancel all dialogs when the user says abort.
        // The SkillDialog automatically sends an EndOfConversation message to the skill to let the
        // skill know that it needs to end its current dialogs, too.
        await innerDc.CancelAllDialogsAsync(cancellationToken);
        return await innerDc.ReplaceDialogAsync(InitialDialogId, "Canceled! \n\n What skill would you like to call?", cancellationToken);
    }

    return await base.OnContinueDialogAsync(innerDc, cancellationToken);
}

AktivitätshandlerlogikActivity handler logic

Da die Skilllogik der einzelnen Durchläufe von einem Hauptdialog verarbeitet wird, ähnelt der Aktivitätshandler dem anderer Dialogbeispiele.Since skill logic for each turn is handled by a main dialog, the activity handler looks much like it would for other dialog samples.

DialogRootBot\Bots\RootBot.csDialogRootBot\Bots\RootBot.cs

public class RootBot<T> : ActivityHandler
    where T : Dialog
private readonly ConversationState _conversationState;
private readonly Dialog _mainDialog;

public RootBot(ConversationState conversationState, T mainDialog)
{
    _conversationState = conversationState;
    _mainDialog = mainDialog;
}
public override async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default)
{
    if (turnContext.Activity.Type != ActivityTypes.ConversationUpdate)
    {
        // Run the Dialog with the Activity.
        await _mainDialog.RunAsync(turnContext, _conversationState.CreateProperty<DialogState>("DialogState"), cancellationToken);
    }
    else
    {
        // Let the base class handle the activity.
        await base.OnTurnAsync(turnContext, cancellationToken);
    }

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

DienstregistrierungService registration

Die Dienste, die für die Verwendung eines Skilldialogs benötigt werden, sind die gleichen, die für einen Skillconsumer im Allgemeinen benötigt werden.The services needed to use a skill dialog are the same as those needed for a skill consumer in general. Eine Erläuterung der erforderlichen Dienste finden Sie unter Implementieren eines Skillconsumers.See how to implement a skill consumer for a discussion of the required services.

Testen des Stamm-BotsTest the root bot

Sie können den Skill-Consumer im Emulator wie einen regulären Bot testen. Sie müssen aber sowohl den Bot für die Qualifikation als auch den Bot für den Skill-Consumer ausführen.You can test the skill consumer in the Emulator as if it were a normal bot; however, you need to run both the skill and skill consumer bots at the same time. Informationen zum Konfigurieren des Skills finden Sie unter Verwenden von Dialogen in einem Skill.See how to use dialogs within a skill for information on how to configure the skill.

Laden Sie die aktuelle Version von Bot Framework Emulator herunter, und installieren Sie sie.Download and install the latest Bot Framework Emulator.

  1. Führen Sie den „dialog skill bot“ und den „dialog root bot“ lokal auf Ihrem Computer aus.Run the dialog skill bot and dialog root bot locally on your machine. Wenn Sie eine Anleitung benötigen, helfen Ihnen die Infodateien für das C#-, JavaScript- bzw. Python-Beispiel weiter.If you need instructions, refer to the README file for the C#, JavaScript or Python sample.
  2. Testen Sie den Bot im Emulator.Use the Emulator to test the bot.
    • Wenn Sie sich zum ersten Mal an der Konversation beteiligen, zeigt der Bot eine Begrüßung an und fragt Sie, welchen Skill Sie aufrufen möchten.When you first join the conversation, the bot displays a welcome message and asks you what skill you would like to call. Der Skillbot für dieses Beispiel hat nur einen Skill.The skill bot for this sample has just one skill.
    • Wählen Sie DialogSkillBot aus.Select DialogSkillBot.
  3. Als Nächstes bittet Sie der Bot, eine Aktion für den Skill auszuwählen.The bot next asks you to choose an action for the skill. Wählen Sie „BookFlight“ aus.Choose "BookFlight".
    1. Beantworten Sie die Eingabeaufforderungen.Answer the prompts.
    2. Der Skill wird abgeschlossen, und der Stammbot zeigt die Buchungsdetails an, bevor er erneut nach dem Skill fragt, den Sie aufrufen möchten.The skill completes, and the root bot displays the booking details before prompting again for the skill you'd like to call.
  4. Wählen Sie erneut DialogSkillBot und „BookFlight“ aus.Select DialogSkillBot again and "BookFlight".
    1. Beantworten Sie die erste Eingabeaufforderung, und geben Sie dann „abort“ ein, um den Skill zu unterbrechen.Answer the first prompt, then enter "abort" to interrupt the skill.
    2. Der Stammbot bricht den Skill und die Eingabeaufforderungen für den Skill ab, den Sie aufrufen möchten.The root bot cancels the skill and prompts for the skill you'd like to call.

Zusätzliche InformationenAdditional information

Weitere allgemeine Informationen zum Implementieren eines Skillconsumers finden Sie unter Implementieren eines Skillconsumers.See how to implement a skill consumer for how to implement a skill consumer in general.