Getting Started with Dialog using Microsoft Bot framework

Introduction:

The Bot Framework enables you to build bots that support different types of interactions with users. You can design conversations in your bot to be freeform. Your bot can also have more guided interactions where it provides the user choices or actions. The conversation can use simple text strings or more complex rich cards that contain text, images, and action buttons. And you can add natural language interactions, which let your users interact with your bots in a natural and expressive way.

Bot Builder SDK introduced Dialogs, Users allow to model conversations and manage conversation flow. Dialogs can contain waterfall steps and prompts(Options). As the user interacts with the bot, the bot will start, stop, and switch between various dialogs in response based on user messages.

In this article, we will learn about the condition inside waterfall Bot Framework.

Prerequisite:

I have explained about Bot framework Installation, deployment and implementation the below article

1. Getting Started with Chatbot Using Azure Bot Service
2. Getting Started with Bots Using Visual Studio 2017
3. Deploying A Bot to Azure Using Visual Studio 2017
4. How to Create ChatBot In Xamarin

Create New Bot Service:

Let start create new bot service application using Visual Studio 2017. Open Visual Studio > Select File > Create New Project (Ctrl + Shift +N) > Select Bot application

The Bot application template was created with all the components and all required NuGet references installed in the solutions .

In this Solution, we have two main class MessagesController.cs and RootDialog.cs , Let we start discuss about here .

RootDialog Class:

Step 1:

You can create / Edit the RootDialog class, create a class that is marked with the [Serializable] attribute (so the dialog can be serialized to state) and implement the IDialog interface.

using System; using System.Threading.Tasks; using Microsoft.Bot.Builder.Dialogs; using Microsoft.Bot.Connector; [Serializable]    public class RootDialog : IDialog<object>    { }

Step 2:

IDialog interface have only StartAsync() methond. StartAsync() is called when the dialog becomes active. The method is passed the IDialogContext object, used to manage the conversation.

public async Task StartAsync(IDialogContext context)        {        }

Step 3:

You can wait for a message from the conversation, call context.Wait(<method name>) and pass it the method you called when the message is received. When MessageReceivedAsync() is called, it's passed the dialog context and an IAwaitable of type IMessageActivity. To get the message, await the result.

[Serializable]    public class RootDialog : IDialog<object>    {        public Task StartAsync(IDialogContext context)        {            context.Wait(MessageReceivedAsync);            return Task.CompletedTask;        }        private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)        {                    }    }

Step 4:

Let start edit MessageReceivedAsync method as per your requirement or create new async method. The following code is welcome message conversation dialog.

[Serializable]    public class RootDialog : IDialog<object>    {        static string username;        int count = 0;        public async Task StartAsync(IDialogContext context)        {            await context.PostAsync("Hello, I am Microsoft Bot");            context.Wait(MessageReceivedAsync);        }        private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)        {            var message = await result as Activity;                        if(count >0)                username = message.Text;            if (string.IsNullOrEmpty(username))            {                await context.PostAsync("what is your good name");                count++;            }            else            {                 await context.PostAsync($"Hello {username} , How may help You");                  }            context.Wait(MessageReceivedAsync);        }    }

IDialogContext have following Public Member Functions

1. Context.Call< R > (IDialog< R > child, ResumeAfter< R > resume)

Call a child dialog and add it to the top of the stack.

2. Context.Done< R > (R value)

Complete the current dialog and return a result to the parent dialog.

3. Context .Fail (Exception error)

Fail the current dialog and return an exception to the parent dialog.

4. Context .Forward< R, T > (IDialog< R > child, ResumeAfter< R > resume, T item, CancellationToken token)

Call a child dialog, add it to the top of the stack and post the item to the child dialog.

5. Context .Post< E > (E @event, ResumeAfter< E > resume)

Post an internal event to the queue.

6. Context .Reset ()

Resets the stack

7. Context .Wait< R > (ResumeAfter< R > resume)

Suspend the current dialog until an external event has been sent to the bot.

MessagesController Class :

The RootDialog class is added to the conversation in the MessageController class via the Post() method. In the Post() method, the call to Conversation.SendAsync() creates an instance of the RootDialog, adds it to the dialog stack to make it the active dialog, calling the RootDialog.StartAsync() from Post method

[BotAuthentication]    public class MessagesController : ApiController    {        /// <summary>        /// POST: api/Messages        /// Receive a message from a user and reply to it        /// </summary>        public async Task<HttpResponseMessage> Post([FromBody]Activity activity)        {            if (activity.Type == ActivityTypes.Message)            {                await Conversation.SendAsync(activity, () => new Dialogs.RootDialog());            }            else            {                HandleSystemMessage(activity);            }            var response = Request.CreateResponse(HttpStatusCode.OK);            return response;        }

Run Bot Application:

The emulator is a desktop application that lets we test and debug our bot on localhost. Now, you can click on "Run the application" in Visual studio and execute in the browser.

Test Application on Bot Emulator

You can follow the below steps to test your bot application.

1. Open Bot Emulator.
2. Copy the above localhost url and paste it in emulator e.g. - http://localHost:3979
3. You can append the /api/messages in the above url; e.g. - http://localHost:3979/api/messages.
4. You won't need to specify Microsoft App ID and Microsoft App Password for localhost testing, so click on "Connect".

Summary:

In this article, your learned how to create a Bot application using Visual Studio 2017 with Bot dialog API. If you have any questions/ feedback/ issues, please write in the comment box.