C# 我的对话框不等待Bot Framework v4中的用户响应

我有两门课：

RootDialog

资格对话框

我的Bot从RootDialog开始，在这里我调用LUIS服务，并根据结果将其指向每个意图的方法

在本例中，我将使用一个名为“intentqualification”的方法，在此方法中，我将调用以下“QualificationDialog”对话框，其中包含集成在waterwall对话框中的SuggestionAction按钮，WaterWallSteps包含两个应按顺序执行的方法：

第一个（Toshow按钮）：显示按钮

第二个（ValidateOptions）：根据按钮捕获用户的选择

问题在于，在显示按钮时，它不会生成等待，也不会转到2方法（ValidateOption），它会退出并结束对话

有谁经历过这个案子谁能帮我

第一次对话

public class RootDialog : ComponentDialog
{
        public RootDialog(ILuisService luisService)
        {
            _luisService = luisService;
            AddDialog(new TextPrompt(nameof(TextPrompt)));
        }
        public override async Task<DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default)
        {
            var luisResult = await _luisService._recognizer.RecognizeAsync(dc.Context, cancellationToken);
            await ManageIntentions(dc, luisResult, cancellationToken);
            return await dc.EndDialogAsync(cancellationToken: cancellationToken);
        }
        private async Task ManageIntentions(DialogContext dc, RecognizerResult luisResult, CancellationToken cancellationToken)
        {
            var topIntent = luisResult.GetTopScoringIntent();
            switch (topIntent.intent)
            {                
                case "Qualify":
                    await IntentQualify(dc, luisResult, cancellationToken);
                    break;
                case "None":
                    await IntentNone(dc, luisResult, cancellationToken);
                    break;
                default:
                    break;
            }
        }
        private async Task IntentQualify(DialogContext dc, RecognizerResult luisResult, CancellationToken cancellationToken)
        {
            // Here I call the second dialog (ss) that contains the buttons and 
            // should generate the wait but does not.
            dc.Dialogs.Add(new QualificationDialog());
            await dc.BeginDialogAsync(nameof(QualificationDialog), null, cancellationToken);
        }


}

public class QualificationDialog: ComponentDialog
    {
        public QualificationDialog()
        {
            var waterfallSteps = new WaterfallStep[]
            {
                ToShowButton,
                ValidateOption
            };
            AddDialog(new WaterfallDialog(nameof(WaterfallDialog), waterfallSteps));
            AddDialog(new TextPrompt(nameof(TextPrompt)));
        }
        public static async Task<DialogTurnResult> ToShowButton(DialogContext stepContext, CancellationToken cancellationToken)
        {
            return await stepContext.PromptAsync(
                  nameof(TextPrompt),
                  new PromptOptions
                  {
                      Prompt = CreateButtonsQualification()
                  },
                  cancellationToken
            );
        }
        private async Task<DialogTurnResult> ValidateOption(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var options = stepContext.Context.Activity.Text;
            return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);
        }
        public static Activity CreateButtonsQualification()
        {
            var reply = MessageFactory.Text("MY TEXT");

            reply.SuggestedActions = new SuggestedActions()
            {
                Actions = new List<CardAction>()
                {
                    new CardAction(){Title = "OPTION 1", Value = "OPTION 1", Type = ActionTypes.ImBack},
                    new CardAction(){Title = "OPTION 2", Value = "OPTION 2", Type = ActionTypes.ImBack},
                    new CardAction(){Title = "OPTION 3", Value = "OPTION 3", Type = ActionTypes.ImBack}
                }
            };
            return reply as Activity;
        }

公共类RootDialog:ComponentDialog
{
公共根对话框（ILuisService luisService）
{
_路易斯服务=路易斯服务；
AddDialog（新建文本提示（名称）（文本提示））；
}
公共重写异步任务BeginDialogAsync（DialogContext dc，对象选项=null，CancellationToken CancellationToken=default）
{
var luisResult=await _luisService.\u recognizer.RecognizeAsync（dc.Context，cancellationToken）；
等待管理意图（dc、luisResult、cancellationToken）；
return wait dc.EndDialogAsync（cancellationToken:cancellationToken）；
}
专用异步任务管理器目标（DialogContext dc、RecogenerResult luisResult、CancellationToken CancellationToken）
{
var topIntent=luisResult.getTopScoringContent（）；
开关（topIntent.intent）
{                
案例“合格”：
等待意向认证（dc、luisResult、cancellationToken）；
打破
案例“无”：
等待IntentOne（dc、luisResult、cancellationToken）；
打破
违约：
打破
}
}
专用异步任务意图资格化（DialogContext dc、RecognizerResult luisResult、CancellationToken CancellationToken）
{
//这里我调用第二个对话框（ss），其中包含按钮和
//应生成等待，但不生成。
添加（新限定对话框（））；
wait dc.BeginDialogAsync（nameof（QualificationDialog），null，cancellationToken）；
}
}

第二段对话

public class RootDialog : ComponentDialog
{
        public RootDialog(ILuisService luisService)
        {
            _luisService = luisService;
            AddDialog(new TextPrompt(nameof(TextPrompt)));
        }
        public override async Task<DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default)
        {
            var luisResult = await _luisService._recognizer.RecognizeAsync(dc.Context, cancellationToken);
            await ManageIntentions(dc, luisResult, cancellationToken);
            return await dc.EndDialogAsync(cancellationToken: cancellationToken);
        }
        private async Task ManageIntentions(DialogContext dc, RecognizerResult luisResult, CancellationToken cancellationToken)
        {
            var topIntent = luisResult.GetTopScoringIntent();
            switch (topIntent.intent)
            {                
                case "Qualify":
                    await IntentQualify(dc, luisResult, cancellationToken);
                    break;
                case "None":
                    await IntentNone(dc, luisResult, cancellationToken);
                    break;
                default:
                    break;
            }
        }
        private async Task IntentQualify(DialogContext dc, RecognizerResult luisResult, CancellationToken cancellationToken)
        {
            // Here I call the second dialog (ss) that contains the buttons and 
            // should generate the wait but does not.
            dc.Dialogs.Add(new QualificationDialog());
            await dc.BeginDialogAsync(nameof(QualificationDialog), null, cancellationToken);
        }


}

public class QualificationDialog: ComponentDialog
    {
        public QualificationDialog()
        {
            var waterfallSteps = new WaterfallStep[]
            {
                ToShowButton,
                ValidateOption
            };
            AddDialog(new WaterfallDialog(nameof(WaterfallDialog), waterfallSteps));
            AddDialog(new TextPrompt(nameof(TextPrompt)));
        }
        public static async Task<DialogTurnResult> ToShowButton(DialogContext stepContext, CancellationToken cancellationToken)
        {
            return await stepContext.PromptAsync(
                  nameof(TextPrompt),
                  new PromptOptions
                  {
                      Prompt = CreateButtonsQualification()
                  },
                  cancellationToken
            );
        }
        private async Task<DialogTurnResult> ValidateOption(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var options = stepContext.Context.Activity.Text;
            return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);
        }
        public static Activity CreateButtonsQualification()
        {
            var reply = MessageFactory.Text("MY TEXT");

            reply.SuggestedActions = new SuggestedActions()
            {
                Actions = new List<CardAction>()
                {
                    new CardAction(){Title = "OPTION 1", Value = "OPTION 1", Type = ActionTypes.ImBack},
                    new CardAction(){Title = "OPTION 2", Value = "OPTION 2", Type = ActionTypes.ImBack},
                    new CardAction(){Title = "OPTION 3", Value = "OPTION 3", Type = ActionTypes.ImBack}
                }
            };
            return reply as Activity;
        }

公共类限定对话框：ComponentDialog
{
公共资格对话框（）
{
var waterwallsteps=新的waterwallstep[]
{
ToShowButton，
验证操作
};
AddDialog（新建WaterWallDialog（名称（WaterWallDialog），WaterWallSteps））；
AddDialog（新建文本提示（名称）（文本提示））；
}
公共静态异步任务ToShowButton（DialogContext stepContext，CancellationToken CancellationToken）
{
return wait stepContext.PromptAsync(
名称（文本提示），
新提示
{
Prompt=CreateButtonsQualification（）
},
取消令牌
);
}
专用异步任务验证操作（WaterWallStepContext stepContext、CancellationToken CancellationToken）
{
var options=stepContext.Context.Activity.Text；
return wait stepContext.EndDialogAsync（cancellationToken:cancellationToken）；
}
公共静态活动CreateButtonsQualification（）
{
var reply=MessageFactory.Text（“我的文本”）；
reply.SuggestedActions=新的SuggestedActions（）
{
操作=新列表（）
{
new CardAction（）{Title=“OPTION 1”，Value=“OPTION 1”，Type=ActionTypes.ImBack}，
new CardAction（）{Title=“OPTION 2”，Value=“OPTION 2”，Type=ActionTypes.ImBack}，
new CardAction（）{Title=“OPTION 3”，Value=“OPTION 3”，Type=ActionTypes.ImBack}
}
};
作为活动返回回复；
}

实现IBot的类

public class MyBot<T> : ActivityHandler where T: Dialog
    {
        BotState _conversationState;
        BotState _userState;
        Dialog _dialog;

        public MyBot(ConversationState conversationState, UserState userState, T dialog)
        {
            _conversationState = conversationState;
            _userState = userState;
            _dialog = dialog;
        }

        protected override async Task OnMembersAddedAsync(IList<ChannelAccount> membersAdded, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
        {
            foreach (var member in membersAdded)
            {
                if (member.Id != turnContext.Activity.Recipient.Id)
                {
                    await turnContext.SendActivityAsync(MessageFactory.Text($"Hello world!"), cancellationToken);
                }
            }
        }

        public override async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default)
        {
            await base.OnTurnAsync(turnContext, cancellationToken);
            await _conversationState.SaveChangesAsync(turnContext, false, cancellationToken);
            await _userState.SaveChangesAsync(turnContext, false, cancellationToken);

        }
        protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
        {
            await _dialog.RunAsync(
              turnContext,
              _conversationState.CreateProperty<DialogState>(nameof(DialogState)),
              cancellationToken
            );
        }

    }

public类MyBot:ActivityHandler其中T:Dialog
{
BotState\u会话状态；
BotState_userState；
对话(Dialog);；
公共MyBot（会话状态会话状态、用户状态、用户状态、T对话框）
{
_会话状态=会话状态；
_userState=userState；
_对话=对话；
}
MemberSaddedAsync上的受保护重写异步任务（IList membersAdded、iTurContext turnContext、CancellationToken CancellationToken）
{
foreach（membersAdded中的var成员）
{
if（member.Id！=turnContext.Activity.Recipient.Id）
{
Wait turnContext.SendActivityAsync（MessageFactory.Text（$“Hello world！”），cancellationToken）；
}
}
}
公共覆盖异步任务OnTurnAsync（ITurnContext turnContext，CancellationToken CancellationToken=default）
{
wait base.OnTurnAsync（turnContext，cancellationToken）；
wait_conversationState.saveChangesSync（turnContext，false，cancellationToken）；
wait_userState.saveChangesSync（turnContext，false，cancellationToken）；
}
受保护的重写异步任务OnMessageActivityAsync（iTurnt上下文