C# 如何在特定条件下调用瀑布的步骤？

我有一个使用c#和v4框架制作的机器人。它总是在提示是/否的情况下询问用户是否希望从bot询问更多问题：

我希望在“点击瀑布的一个特定条件应该被调用”上，否则在所有其他条件下，瀑布的步骤应该被跳过，机器人应该正常工作。我还添加了代码，仅供参考

主对话框的代码

public MainDialog(ILogger<MainDialog> logger, IBotServices botServices, UserState userState) : 
     base(nameof(MainDialog))
{ _botServices = botServices;// ?? throw new System.ArgumentNullException(nameof(botServices));
   _logger = logger;
        _userState = userState;
        AddDialog(new ProductIssue($"{nameof(MainDialog)}.fromMain", _botServices, _userState));
        AddDialog(new ProductIssue($"{nameof(Confirm)}.fromConfirm", _botServices, _userState));
        AddDialog(new ProductIssue($"{ nameof(Resolution)}.resolution", _botServices, _userState));
        AddDialog(new PurchaseFlow(_userState));
        AddDialog(new Resolution( _userState));
        AddDialog(new Confirm(_botServices,_userState));
        AddDialog(new ChoicePrompt($"{nameof(MainDialog)}.issue"));
        AddDialog(new TextPrompt($"{nameof(MainDialog)}.callDialog"));
        AddDialog(new TextPrompt($"{nameof(MainDialog)}.number", ValidationAsync));


        AddDialog(new WaterfallDialog($"{nameof(MainDialog)}.mainFlow", new WaterfallStep[]
        {
            MoblieNumberAsync,
            ChoiceCardStepAsync,
            ShowCardStepAsync,
            CallingDialogsAsync
      }));
        AddDialog(new TextPrompt(nameof(TextPrompt)));

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

    }

    private async Task<DialogTurnResult> MoblieNumberAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
    {
        stepContext.Values[UserInfo] = new UserInput();
        var options = new PromptOptions()
        {
            Prompt = MessageFactory.Text("Kindly enter your 10 digit mobile number without any spaces, dashes and country code. We will be sending an OTP later to this number "),
            RetryPrompt = MessageFactory.Text("Incorrect mobile number entered. Please only enter the 10 digits of your mobile without any spaces, dashes and country code.")
        };     

        return await stepContext.PromptAsync($"{nameof(MainDialog)}.number", options, cancellationToken);
    }

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

        var userStateAccessors = _userState.CreateProperty<UserInput>(nameof(UserInput));
        var userinfo = await userStateAccessors.GetAsync(stepContext.Context, () => new UserInput());
        userinfo.phone_no = (string)stepContext.Result;
        CustomerDetails customerDetails = new CustomerDetails();

        //API-Get Customer Details from CRM
        try
        {
            BotAPIBLL botApiBLL = new BotAPIBLL();
            var response = botApiBLL.GetCustomerDetail(stepContext.Context.Activity.Text); 
            customerDetails = JsonConvert.DeserializeObject<CustomerDetails>(response);               
        }
        catch(Exception ex)
        {

        }
        await stepContext.Context.SendActivityAsync(MessageFactory.Text("Fetching your details from our systems. This may take a moment"), cancellationToken);

        if (customerDetails.D != null && !string.IsNullOrEmpty(customerDetails.D.TelNumber) && !string.IsNullOrEmpty(customerDetails.D.NameFirst))
        {
            DbConnection dbConnection = new DbConnection();
            dbConnection.SaveCutomerInfo(customerDetails);

            userinfo.Name = customerDetails.D.NameFirst;
            var options = new PromptOptions()
            {

                Prompt = MessageFactory.Text("Welcome " + customerDetails.D.NameFirst + ", How can we serve you ? "),
                RetryPrompt = MessageFactory.Text("That was not a valid choice, please select a option between 1 to 5."),
                Choices = GetChoices(),
                Style = ListStyle.HeroCard
            };
            return await stepContext.PromptAsync($"{nameof(MainDialog)}.issue", options, cancellationToken);
        }
        else
        {
            var options = new PromptOptions()
            {
                Prompt = MessageFactory.Text("Welcome Guest_" + userinfo.phone_no + ", How can we serve you ? "),
                RetryPrompt = MessageFactory.Text("That was not a valid choice, please select a option between 1 to 5."),
                Choices = GetChoices(),
                Style = ListStyle.HeroCard
            };
            return await stepContext.PromptAsync($"{nameof(MainDialog)}.issue", options, cancellationToken);
        }
    }

    private async Task<DialogTurnResult> ShowCardStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
    {
        var userinfo = (UserInput)stepContext.Values[UserInfo];
        userinfo.choiceselected = ((FoundChoice)stepContext.Result).Value;
        var attachments = new List<Attachment>();
        var reply = MessageFactory.Text("");
        var user_choice = ((FoundChoice)stepContext.Result).Value;

        switch (user_choice)
        {
            case "Product issue":
                reply.Attachments.Add(Cards.CreateAdaptiveCardAttachment3());
                break;
            case "Register Product":
                reply.Attachments.Add(Cards.GetHeroCard1().ToAttachment());
                break;
            case "Online Purchase":
                return await stepContext.BeginDialogAsync(nameof(PurchaseFlow), null, cancellationToken);
            case "Customer Grivance":
                reply.Attachments.Add(Cards.GetHeroCard3().ToAttachment());
                break;
            case "Order Status":
                reply.Attachments.Add(Cards.GetHeroCard6().ToAttachment());
                break;
            default:
                reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
                reply.Attachments.Add(Cards.CreateAdaptiveCardAttachment3());
                reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
                reply.Attachments.Add(Cards.GetHeroCard1().ToAttachment());
                break;
        }
        if (user_choice == "Register Product" || user_choice == "Online Purchase" || user_choice == "Customer Grivance")
        {
            await stepContext.Context.SendActivityAsync(reply, cancellationToken);
            Random r = new Random();
            var validationcard = Cards.CreateAdaptiveCardAttachment2(_cards[r.Next(_cards.Length)]);
            //var feedbackcard = Cards.CustomerFeedback();
            await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(validationcard), cancellationToken);
            //await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(feedbackcard), cancellationToken);
            var accessor = _userState.CreateProperty<UserInput>(nameof(UserInput));
            await accessor.SetAsync(stepContext.Context, userinfo, cancellationToken);
            return await stepContext.EndDialogAsync(null, cancellationToken);
        }
        else
        {
            var options2 = new PromptOptions() { Prompt = reply, RetryPrompt = MessageFactory.Text("Retry") };                
            return await stepContext.PromptAsync($"{nameof(MainDialog)}.callDialog", options2, cancellationToken);
        }
    }

    private async Task<DialogTurnResult> CallingDialogsAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
    {                      
        // First, we use the dispatch model to determine which cognitive service (LUIS or QnA) to use.
        var recognizerResult = await _botServices.Dispatch.RecognizeAsync(stepContext.Context, cancellationToken);

        // Top intent tell us which cognitive service to use.
        var topIntent = recognizerResult.GetTopScoringIntent();

        switch (topIntent.intent)
        {

            case "Mainissue":
                 return await stepContext.BeginDialogAsync($"{nameof(MainDialog)}.fromMain", stepContext.Values[UserInfo], cancellationToken);

            case "ConfirmIntent":
                return await stepContext.BeginDialogAsync(nameof(Confirm), null, cancellationToken);

            case "EndBotIntent":
                return await stepContext.CancelAllDialogsAsync(true, null, null, cancellationToken);

            case "InverterData":
                await ProcessSampleQnAAsync(stepContext, cancellationToken);
                break;
            default:
                await stepContext.Context.SendActivityAsync(MessageFactory.Text($"I'm sorry I don't know what you mean."), cancellationToken);
                break;
         }
        return await stepContext.EndDialogAsync(null, cancellationToken);
    }

    private IList<Choice> GetChoices()
    {
        var cardOptions = new List<Choice>()
            {

                new Choice() { Value = "Product issue", Synonyms = new List<string>() { "adaptive" } },
                new Choice() { Value = "Register Product", Synonyms = new List<string>() { "hero" } },
                new Choice() { Value = "Online Purchase", Synonyms = new List<string>() { "hero" } },
                new Choice() { Value = "Customer Grivance", Synonyms = new List<string>() { "hero" } },
                new Choice() { Value = "Order Status", Synonyms = new List<string>() { "hero" } }
            };

        return cardOptions;
    }

    private Task<bool> ValidationAsync(PromptValidatorContext<string> promptContext, CancellationToken cancellationToken)
    {
        string value = (string)promptContext.Context.Activity.Text;
        if (Regex.IsMatch(value, "^[0-9]{10}$"))
        {
            return Task.FromResult(true);
        }
        else
        {
            return Task.FromResult(false);
        }
    }

    private async Task ProcessSampleQnAAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
    {
        _logger.LogInformation("ProcessSampleQnAAsync");

        var results = await _botServices.SampleQnA.GetAnswersAsync(stepContext.Context);
        if (results.Any())
        {
            await stepContext.Context.SendActivityAsync(MessageFactory.Text(results.First().Answer), cancellationToken);
        }
        else
        {
            await stepContext.Context.SendActivityAsync(MessageFactory.Text("Sorry, could not find an answer in the Q and A system."), cancellationToken);
        }
    }
}

public main对话框（ILogger记录器、IBotServices机器人服务、用户状态用户状态）：
基本（名称（主对话框））
{u botServices=botServices；//？抛出新的System.ArgumentNullException（nameof（botServices））；
_记录器=记录器；
_userState=userState；
AddDialog（新产品发行（$“{nameof（mainlialog）}.fromMain”，_botServices，_userState））；
AddDialog（新产品发行（$“{nameof（Confirm）}.fromConfirm”，\u botServices，\u userState））；
AddDialog（新产品问题（$“{nameof（Resolution）}.Resolution”，\u botServices，\u userState））；
AddDialog（新采购流程（_userState））；
AddDialog（新解析（_userState））；
AddDialog（新确认（_botServices，_userState））；
AddDialog（新的ChoicePrompt（$“{nameof（MainDialog）}.issue”）；
AddDialog（新的文本提示（$“{nameof（MainDialog）}.callDialog”）；
AddDialog（新的文本提示（$“{nameof（MainDialog）}.number”，ValidationAsync））；
AddDialog（新建WaterWallDialog（$“{nameof（MainDialog）}.mainFlow”），新建WaterWallStep[]
{
MoblieNumberAsync，
ChoiceCardStepAsync，
ShowCardStepAsync，
调用对话框sasync
}));
AddDialog（新建文本提示（名称）（文本提示））；
InitialDialogId=$“{nameof（MainDialog）}.mainFlow”；
}
专用异步任务MoblieNumberAsync（WaterAllStepContext stepContext，CancellationToken CancellationToken）
{
stepContext.Values[UserInfo]=newuserinput（）；
var options=新的prompoptions（）
{
Prompt=MessageFactory.Text（“请输入您的10位移动电话号码，不带空格、破折号和国家/地区代码。我们稍后将向该号码发送OTP”），
RetryPrompt=MessageFactory.Text（“输入的手机号码不正确。请只输入手机的10位数字，不带空格、破折号和国家代码。”）
};     
返回wait wait stepContext.PromptAsync（$“{nameof（MainDialog）}.number”，选项，取消令牌）；
}
专用异步任务选项CardStepAsync（WaterWallStepContext stepContext，CancellationToken CancellationToken）
{
var userStateAccessors=_userState.CreateProperty（nameof（UserInput））；
var userinfo=await userStateAccessors.GetAsync（stepContext.Context，（）=>newuserinput（））；
userinfo.phone_no=（字符串）stepContext.Result；
CustomerDetails CustomerDetails=新CustomerDetails（）；
//API从CRM获取客户详细信息
尝试
{
BotAPIBLL BotAPIBLL=新的BotAPIBLL（）；
var response=botApiBLL.GetCustomerDetail（stepContext.Context.Activity.Text）；
customerDetails=JsonConvert.DeserializeObject（响应）；
}
捕获（例外情况除外）
{
}
等待stepContext.Context.SendActivityAsync（MessageFactory.Text（“正在从我们的系统获取您的详细信息，这可能需要一些时间”）、cancellationToken；
if（customerDetails.D！=null&&！string.IsNullOrEmpty（customerDetails.D.TelNumber）&&！string.IsNullOrEmpty（customerDetails.D.NameFirst））
{
DbConnection DbConnection=新的DbConnection（）；
dbConnection.SaveCutomerInfo（customerDetails）；
userinfo.Name=customerDetails.D.NameFirst；
var options=新的prompoptions（）
{
Prompt=MessageFactory.Text（“欢迎”+customerDetails.D.NameFirst+”，我们如何为您服务，
RetryPrompt=MessageFactory.Text（“这不是一个有效的选择，请选择一个介于1到5之间的选项”），
Choices=GetChoices（），
Style=ListStyle.HeroCard
};
返回wait wait stepContext.PromptAsync（$“{nameof（MainDialog）}.issue”，选项，取消令牌）；
}
其他的
{
var options=新的prompoptions（）
{
Prompt=MessageFactory.Text（“欢迎来宾”+userinfo.phone\u no+”，我们如何为您服务，
RetryPrompt=MessageFactory.Text（“这不是一个有效的选择，请选择一个介于1到5之间的选项”），
Choices=GetChoices（），
Style=ListStyle.HeroCard
};
返回wait wait stepContext.PromptAsync（$“{nameof（MainDialog）}.issue”，选项，取消令牌）；
}
}
专用异步任务ShowCardStepAsync（WaterWallStepContext stepContext，CancellationToken CancellationToken）
{
var userinfo=（UserInput）stepContext.Values[userinfo]；
userinfo.choiceselected=（（FoundChoice）stepContext.Result）.Value；
var attachments=新列表（）；
var reply=MessageFactory.Text（“”）；
var user_choice=（（FoundChoice）stepContext.Result）.Value；
开关（用户选择）
{
案例“产品问题”：
reply.Attachments.Add（Cards.CreateAdaptiveCardAttachment3（））；
打破
案例“注册产品”：
reply.Attachments.Add（Cards.GetHeroCard1（）.ToAttachment（））；
打破
“网上购物”案例：
return wait stepContext.BeginDialogAsync（nameof（PurchaseFlow），null，cancellationToken）；
案例“客户欺诈”：
reply.Attachments.Add（Cards.GetHeroCard3（）.ToAttachment（））；
打破
案例“订单状态”：
reply.Attachments.Add（Cards.GetHeroCard6（）.ToAttachment（））；
打破
违约：
reply.AttachmentLayout=附加
if (condition)
{
    await stepContext.NextAsync(stepContext.Result, cancellationToken);
}

// otherwise process this step