Prompt And Waterfall Dialog In Bot V4 Framework Bot Builder 😍 .NET Core

If a Bot framework handles one query, two functions get involved, one function handles the question, another one handles the answers. Waterfall works the same way.

Create a relation function with the same arguments, and use the WaterfallStepContext to get the result.

Let's see one example of how to implement this feature. In this example, we are going to read the username, mobile number, language list, and datetime.

// Copyright (c) Microsoft Corporation. All rights reserved.  
// Licensed under the MIT License.  
using System;  
using System.Collections.Generic;  
using System.Threading;  
using System.Threading.Tasks;  
using Microsoft.Bot.Builder;  
using Microsoft.Bot.Builder.Dialogs;  
using Microsoft.Bot.Builder.Dialogs.Choices;  
using Microsoft.Bot.Schema;  
namespace BotPrompt  
{  
    /// <summary>  
    /// Represents a bot that processes incoming activities.  
    /// For each user interaction, an instance of this class is created and the OnTurnAsync method is called.  
    /// This is a Transient lifetime service. Transient lifetime services are created  
    /// each time they're requested. Objects that are expensive to construct, or have a lifetime  
    /// beyond a single turn, should be carefully managed.  
    /// For example, the <see cref="MemoryStorage"/> object and associated  
    /// <see cref="IStatePropertyAccessor{T}"/> object are created with a singleton lifetime.  
    /// </summary>  
    /// <seealso cref="https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-2.1"/>  
    public class BotPromptBot : IBot  
    {  
        /// <summary>  
        /// Initializes a new instance of the class.  
        /// </summary>  
        private readonly DialogSet _dialogSet;  
        private readonly StateAccessor _stateAccessor;  
  
        private readonly string DlgMainId = "MainDialog";  
        private readonly string DlgNameId = "NameDlg";  
        private readonly string DlgMobileId = "MobileDlg";  
        private readonly string DlgLanguageId = "LanguageListDlg";  
        private readonly string DlgDateTimeId = "DateTimeDlg";  
        public BotPromptBot(StateAccessor stateAccessor)  
        {  
            _stateAccessor = stateAccessor;  
            _dialogSet = new DialogSet(stateAccessor.DlgState);  
            _dialogSet.Add(new TextPrompt(DlgNameId, UserNameValidation));  
            _dialogSet.Add(new NumberPrompt<int>(DlgMobileId, MobileNumberValidation));  
            _dialogSet.Add(new ChoicePrompt(DlgLanguageId, ChoiceValidataion));  
            _dialogSet.Add(new DateTimePrompt(DlgDateTimeId));  
  
            var waterfallSteps = new WaterfallStep[]  
            {  
                UserNameAsync,  
                GetUserNameAsync,  
                MobileNumberAsync,  
                SelectLanguageList,  
                DateTimeAsync,  
            };  
  
            _dialogSet.Add(new WaterfallDialog(DlgMainId, waterfallSteps));  
        }  
        private Task<bool> ChoiceValidataion(PromptValidatorContext<FoundChoice> promptContext, CancellationToken cancellationToken)  
        {  
            return Task.FromResult(true);  
        }  
        private Task<bool> UserNameValidation(PromptValidatorContext<string> promptContext, CancellationToken cancellationToken)  
        {  
            return Task.FromResult(true);  
        }  
        private async Task<bool> MobileNumberValidation(PromptValidatorContext<int> promptContext, CancellationToken cancellationToken)  
        {  
            if (!promptContext.Recognized.Succeeded)  
            {  
                await promptContext.Context.SendActivityAsync("Hello, Please enter the valid mobile no",  
                    cancellationToken: cancellationToken);  
  
                return false;  
            }  
            int count = Convert.ToString(promptContext.Recognized.Value).Length;  
            if (count != 10)  
            {  
                await promptContext.Context.SendActivityAsync("Hello, you are missing some number!!!",  
                    cancellationToken: cancellationToken);  
                return false;  
            }  
            return true;  
        }  
        private async Task<DialogTurnResult> GetUserNameAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)  
        {  
            var name = (string)stepContext.Result;  
  
            return await stepContext.PromptAsync(DlgMobileId, new PromptOptions  
            {  
                Prompt = MessageFactory.Text("Please enter the mobile No"),  
                RetryPrompt = MessageFactory.Text("Enter Valid mobile No")  
            }, cancellationToken);  
        }  
        private async Task<DialogTurnResult> UserNameAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)  
        {  
            return await stepContext.PromptAsync(DlgNameId, new PromptOptions  
            {  
                Prompt = MessageFactory.Text("Hello!!!, Please enter the Name")  
            }, cancellationToken);  
        }  
        private async Task<DialogTurnResult> MobileNumberAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)  
        {  
            var mobileNo = stepContext.Result;  
  
            var newMovieList = new List<string> { "Tamil", "English", "kaanda" };  
  
            return await stepContext.PromptAsync(DlgLanguageId, new PromptOptions  
            {  
                Prompt = MessageFactory.Text("Please select the Language"),  
                Choices = ChoiceFactory.ToChoices(newMovieList),  
                RetryPrompt = MessageFactory.Text("Select from the List")  
            }, cancellationToken);  
        }  
        private async Task<DialogTurnResult> SelectLanguageList(WaterfallStepContext stepContext, CancellationToken cancellationToken)  
        {  
            var choice = (FoundChoice)stepContext.Result;  
  
            return await stepContext.PromptAsync(DlgDateTimeId, new PromptOptions  
            {  
                Prompt = MessageFactory.Text("Please select the Date")  
            }, cancellationToken);  
        }  
        private async Task<DialogTurnResult> DateTimeAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)  
        {  
            var datetime = stepContext.Result;  
  
            return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);  
        }  
  
        /// <summary>  
        /// Every conversation turn calls this method.  
        /// </summary>  
        /// <param name="turnContext">A <see cref="ITurnContext"/> containing all the data needed  
        /// for processing this conversation turn. </param>  
        /// <param name="cancellationToken">(Optional) A <see cref="CancellationToken"/> that can be used by other objects  
        /// or threads to receive notice of cancellation.</param>  
        /// <returns>A <see cref="Task"/> that represents the work queued to execute.</returns>  
        /// <seealso cref="BotStateSet"/>  
        /// <seealso cref="ConversationState"/>  
        public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))  
        {  
            // Handle Message activity type, which is the main activity type for shown within a conversational interface  
            // Message activities may contain text, speech, interactive cards, and binary or unknown attachments.  
            // see https://aka.ms/about-bot-activity-message to learn more about the message and other activity types  
            if (turnContext.Activity.Type == ActivityTypes.Message)  
            {  
                DialogContext dlgContext = await _dialogSet.CreateContextAsync(turnContext, cancellationToken: cancellationToken);  
  
                if (dlgContext != null && dlgContext.ActiveDialog is null)  
                {  
                    await dlgContext.BeginDialogAsync(DlgMainId, null, cancellationToken);  
                }  
                else if (dlgContext != null && dlgContext.ActiveDialog != null)  
                {  
                    await dlgContext.ContinueDialogAsync(cancellationToken);  
                }  
                await _stateAccessor.Conversation.SaveChangesAsync(turnContext, false, cancellationToken);  
            }  
        }  
    }  
}  

Once all the queries have been completed, finally call the EndDialogAsync to complete dialog functionality.

You can find the complete sample here.

Conclusion

I hope you understand how to implement the Prompt waterfall dialogs. In the next article, we will see how to implement the custom validation.

Happy Reading. Happy coding.