通过跳过bot框架v4中第一个对话的第一步，将第一个对话的瀑布步骤调用到另一个对话中

Question

I have 3 dialogs in my bot framework v4 C# project, having waterfall steps in each.

In my second dialog have to behave the same as the first dialog but it doesn't have to execute all the steps of the first dialog, which means I need to skip the first step.

So is there any method to invoke all the waterfall steps of the first dialog into the other dialog by skipping the first step of the first dialog.

Answer 1

A waterfall once formed is supposed to be executed in a step-by-step fashion. However, you can do the formation of your waterfall steps conditionally.

The condition here can be based on DialogId .

It's quite difficult to understand what exactly you're trying to do so, I've formed a sample solution for you. Hope you're trying to do the same.

Please refer the below code for the same :

MainDialog.cs

    namespace EchoBot.Dialogs
    {
        public class MainDialog : ComponentDialog
        {
            private readonly BotStateService _botStateService;

            public MainDialog(BotStateService botStateService) : base(nameof(MainDialog))
            {
                _botStateService = botStateService;

                InitializeWaterfallDialog();
            }

            private void InitializeWaterfallDialog()
            {
                var waterfallSteps = new WaterfallStep[]
                {
                    InitialStepAsync,
                    FinalStepAsync
                };

                AddDialog(new SecondDialog($"{nameof(MainDialog)}.second", _botStateService));
                AddDialog(new FirstDialog($"{nameof(MainDialog)}.first", _botStateService)); 
AddDialog(new FirstDialog($"{nameof(SecondDialog)}.firstFromSecond", _botStateService));
                AddDialog(new WaterfallDialog($"{nameof(MainDialog)}.mainFlow", waterfallSteps));

                InitialDialogId = $"{nameof(MainDialog)}.mainFlow";
            }

            private async Task<DialogTurnResult> InitialStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
            {
                if (Regex.Match(stepContext.Context.Activity.Text.ToLower(), "hi").Success)
                {
                    return await stepContext.BeginDialogAsync($"{nameof(MainDialog)}.second", null, cancellationToken);
                }
                else
                {
                    return await stepContext.BeginDialogAsync($"{nameof(MainDialog)}.first", null, cancellationToken);
                }

            }

            private async Task<DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
            {
               return await stepContext.EndDialogAsync(null,cancellationToken);
            }
        } }

FirstDialog.cs

    namespace EchoBot.Dialogs
{
    public class FirstDialog : ComponentDialog
    {
        private readonly BotStateService _botStateService;

        public FirstDialog(string dialogId, BotStateService botStateService) : base(dialogId)
        {
            _botStateService = botStateService ?? throw new ArgumentNullException(nameof(botStateService));
            if (dialogId == $"{ nameof(MainDialog)}.first")
                InitializeWaterfallDialog1();
            else
                InitializeWaterfallDialog2();
        }

        private void InitializeWaterfallDialog1()
        {
            var waterfallsteps = new WaterfallStep[]
            {
                GetAge,
                GetCity,
                FinalStepAsync
            };
            AddDialog(new WaterfallDialog($"{nameof(FirstDialog)}.mainFlow", waterfallsteps));
            AddDialog(new NumberPrompt<int>($"{nameof(FirstDialog)}.age"));
            AddDialog(new TextPrompt($"{nameof(FirstDialog)}.city"));

            InitialDialogId = $"{nameof(FirstDialog)}.mainFlow";
        }
        private void InitializeWaterfallDialog2()
        {
            var waterfallsteps = new WaterfallStep[]
            {
                GetCity,
                FinalStepAsync
            };
            AddDialog(new WaterfallDialog($"{nameof(FirstDialog)}.mainFlow", waterfallsteps));
            AddDialog(new NumberPrompt<int>($"{nameof(FirstDialog)}.age"));
            AddDialog(new TextPrompt($"{nameof(FirstDialog)}.city"));

            InitialDialogId = $"{nameof(FirstDialog)}.mainFlow";
        }

        private async Task<DialogTurnResult> GetAge(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            return await stepContext.PromptAsync($"{nameof(FirstDialog)}.age",
                new PromptOptions
                {
                    Prompt = MessageFactory.Text("Please enter your age."),
                    RetryPrompt = MessageFactory.Text("Please enter a valid age.")
                }, cancellationToken);
        }

        private async Task<DialogTurnResult> GetCity(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            return await stepContext.PromptAsync($"{nameof(FirstDialog)}.age",
                 new PromptOptions
                 {
                     Prompt = MessageFactory.Text("Please enter your city."),
                     RetryPrompt = MessageFactory.Text("Please enter a valid city.")
                 }, cancellationToken);
        }

        private async Task<DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            return await stepContext.EndDialogAsync(null, cancellationToken);
        }
    }}

SecondDialog.cs

    namespace EchoBot.Dialogs
{
    public class SecondDialog : ComponentDialog
    {
        private readonly BotStateService _botStateService;

        public SecondDialog(string dialogId, BotStateService botStateService) : base(dialogId) 
        {
            _botStateService = botStateService ?? throw new ArgumentNullException(nameof(botStateService));

            InitializeWaterfallDialog();
        }

        private void InitializeWaterfallDialog()
        {
            var waterfallSteps = new WaterfallStep[]
            {
                InitialStepAsync,
                FinalStepAsync
            };

            AddDialog(new WaterfallDialog($"{nameof(SecondDialog)}.mainFlow", waterfallSteps));
            AddDialog(new TextPrompt($"{nameof(SecondDialog)}.name"));


            InitialDialogId = $"{nameof(SecondDialog)}.mainFlow";
        }

        private async Task<DialogTurnResult> InitialStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
                return await stepContext.PromptAsync($"{nameof(SecondDialog)}.name",
                    new PromptOptions
                    {
                        Prompt = MessageFactory.Text("Please enter your Name.")
                    }, cancellationToken);
        }

        private async Task<DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {

            //Suppose you want to call First Dialog from here
            return await stepContext.BeginDialogAsync($"{nameof(SecondDialog)}.firstFromSecond", null, cancellationToken);
        }
    }
}

Added one line - AddDialog(new FirstDialog($"{nameof(SecondDialog)}.firstFromSecond", _botStateService)); in MainDialog.cs . It's working fine for me.

Image 1 : When you go into second dialog from Main Dialog, it asks name and then skips first step of First Dialog (ie. age) and asks the second step ie. city.

Image 2 : When you go directly into first dialog from Main Dialog, it asks age and city both ie. it didn't skip first step.

Hope this is helpful. Ask in comments if you have any query!