Bot Builder SDK V4 pour .NET : apprendre à mettre en place une conversation guidée avec la bibliothèque Dialogs

Par Hinault Romaric

1
2
3
4
5
6
  public class FeedbackData 
    { 
        public string Name { get; set; } 
        public string Email { get; set; } 
        public string Message { get; set; } 
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class BotAccessors 
    { 
        /// <summary> 
        /// Initializes a new instance of the <see cref="BotAccessors"/> class. 
        /// Contains the <see cref="ConversationState"/> and associated <see cref="IStatePropertyAccessor{T}"/>. 
        /// </summary> 
        /// <param name="conversationState">The state object that stores the conversationState.</param> 
        /// <param name="userState">The state object that stores the userState.</param> 
        public BotAccessors(ConversationState conversationState, UserState userState) 
        { 
            ConversationState = conversationState ?? throw new ArgumentNullException(nameof(conversationState)); 
            UserState = userState ?? throw new ArgumentNullException(nameof(userState)); 
        } 
  
        /// <summary> 
        /// Gets or sets the <see cref="IStatePropertyAccessor{T}"/> for FeedbackData. 
        /// </summary> 
        /// <value> 
        /// The accessor stores the FeedbackData for the conversation. 
        /// </value> 
        public IStatePropertyAccessor<FeedbackData> FeedbackData { get; set; } 
  
  
        /// <summary> 
        /// Gets or sets the <see cref="IStatePropertyAccessor{T}"/> for ConversationDialogState. 
        /// </summary> 
        /// <value> 
        /// The accessor stores the ConversationDialogState for the conversation. 
        /// </value> 
        public IStatePropertyAccessor<DialogState> ConversationDialogState { get; set; } 
  
  
        /// <summary> 
        /// Gets the <see cref="ConversationState"/> object for the conversation. 
        /// </summary> 
        /// <value>The <see cref="ConversationState"/> object.</value> 
        public ConversationState ConversationState { get; } 
  
        /// <summary> 
        /// Gets the <see cref="UserState"/> object for the conversation. 
        /// </summary> 
        /// <value>The <see cref="UserState"/> object.</value> 
        public UserState UserState { get; } 
    }

1
2
3
4
5
6
7
public class RequestFeedbackDialog : IBot 
    { 
        public Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken)) 
        { 
            throw new NotImplementedException(); 
        } 
    }

1
2
3
private readonly BotAccessors _accessors; 
private readonly ILogger _logger; 
private DialogSet _dialogs;

1
2
// The DialogSet needs a DialogState accessor, it will call it when it has a turn context. 
  _dialogs = new DialogSet(accessors.ConversationDialogState);

1
2
3
4
5
6
7
8
var waterfallSteps = new WaterfallStep[] 
            { 
                RequestStepAsync, 
                NameStepAsync, 
                NameConfirmStepAsync, 
                EmailConfirmStepAsync, 
                SummaryStepAsync, 
            };

1
2
3
4
5
6
 // Add named dialogs to the DialogSet. These names are saved in the dialog state. 
            _dialogs.Add(new WaterfallDialog("details", waterfallSteps)); 
            _dialogs.Add(new ConfirmPrompt("confirm", defaultLocale: Culture.French)); 
            _dialogs.Add(new TextPrompt("nom")); 
            _dialogs.Add(new TextPrompt("email", EmailPromptValidatorAsync)); 
            _dialogs.Add(new TextPrompt("message"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
_accessors = accessors ?? throw new ArgumentNullException(nameof(accessors)); 
  
            if (loggerFactory == null) 
            { 
                throw new System.ArgumentNullException(nameof(loggerFactory)); 
            } 
  
            _logger = loggerFactory.CreateLogger<RequestFeedbackDialog>(); 
            _logger.LogTrace("RequestFeedbackDialogBot turn start."); 
  
            // The DialogSet needs a DialogState accessor, it will call it when it has a turn context. 
            _dialogs = new DialogSet(accessors.ConversationDialogState); 
  
            // This array defines how the Waterfall will execute. 
            var waterfallSteps = new WaterfallStep[] 
            { 
                RequestStepAsync, 
                NameStepAsync, 
                NameConfirmStepAsync, 
                EmailConfirmStepAsync, 
                SummaryStepAsync, 
            }; 
  
            // Add named dialogs to the DialogSet. These names are saved in the dialog state. 
            _dialogs.Add(new WaterfallDialog("details", waterfallSteps)); 
            _dialogs.Add(new ConfirmPrompt("confirm", defaultLocale: Culture.French)); 
            _dialogs.Add(new TextPrompt("nom")); 
            _dialogs.Add(new TextPrompt("email", EmailPromptValidatorAsync)); 
            _dialogs.Add(new TextPrompt("message"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 private Task<DialogTurnResult> RequestStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            throw new NotImplementedException(); 
        } 
  
        private Task<DialogTurnResult> NameStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            throw new NotImplementedException(); 
        } 
  
        private Task<DialogTurnResult> NameConfirmStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            throw new NotImplementedException(); 
        } 
  
        private Task<DialogTurnResult> EmailConfirmStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            throw new NotImplementedException(); 
        } 
  
        private Task<DialogTurnResult> SummaryStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            throw new NotImplementedException(); 
        } 
  
        private Task<bool> EmailPromptValidatorAsync(PromptValidatorContext<string> promptContext, CancellationToken cancellationToken) 
        { 
            throw new NotImplementedException(); 
        }

1
2
3
4
5
6
7
8
9
10
11
/// <summary> 
        /// One of the functions that make up the <see cref="WaterfallDialog"/>. 
        /// </summary> 
        /// <param name="stepContext">The <see cref="WaterfallStepContext"/> gives access to the executing dialog runtime.</param> 
        /// <param name="cancellationToken">A <see cref="CancellationToken"/>.</param> 
        /// <returns>A <see cref="DialogTurnResult"/> to communicate some flow control back to the containing WaterfallDialog.</returns> 
        private async Task<DialogTurnResult> RequestStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog. 
            return await stepContext.PromptAsync("confirm", new PromptOptions { Prompt = MessageFactory.Text("Voulez-vous nous laisser vos commentaires ?") }, cancellationToken); 
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private async Task<DialogTurnResult> NameStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            if ((bool)stepContext.Result) 
            { 
                // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog. 
                // Running a prompt here means the next WaterfallStep will be run when the users response is received. 
                return await stepContext.PromptAsync("nom", new PromptOptions { Prompt = MessageFactory.Text("Veuillez saisir votre nom.") }, cancellationToken); 
            } 
            else 
            { 
                await stepContext.Context.SendActivityAsync(MessageFactory.Text("Merci. Au revoir."), cancellationToken); 
                return await stepContext.EndDialogAsync(cancellationToken: cancellationToken); 
  
            } 
        }

1
2
3
4
5
6
7
8
9
10
11
private async Task<DialogTurnResult> NameConfirmStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            // Get the current feedbackData object from user state. 
            var feedbackData = await _accessors.FeedbackData.GetAsync(stepContext.Context, () => new FeedbackData(), cancellationToken); 
  
            // Update the feedbackData. 
            feedbackData.Name = (string)stepContext.Result; 
  
            // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog. 
            return await stepContext.PromptAsync("email", new PromptOptions { Prompt = MessageFactory.Text("Veuillez saisir votre adresse email.") }, cancellationToken); 
        }

1
2
3
4
5
6
7
8
9
10
11
private async Task<DialogTurnResult> EmailConfirmStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            // Get the current feedbackData object from user state. 
            var feedbackData = await _accessors.FeedbackData.GetAsync(stepContext.Context, () => new FeedbackData(), cancellationToken); 
  
            // Update the feedbackData. 
            feedbackData.Email = (string)stepContext.Result; 
  
            // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog. 
            return await stepContext.PromptAsync("message", new PromptOptions { Prompt = MessageFactory.Text("Veuillez saisir votre message.") }, cancellationToken); 
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private async Task<DialogTurnResult> SummaryStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
  
            // Get the current feedbackData object from user state. 
            var feedbackData = await _accessors.FeedbackData.GetAsync(stepContext.Context, () => new FeedbackData(), cancellationToken); 
  
            // Update the feedbackData. 
            feedbackData.Message = (string)stepContext.Result; 
  
            await stepContext.Context.SendActivityAsync(MessageFactory.Text($"Votre nom {feedbackData.Name}, votre email {feedbackData.Email} et votre message {feedbackData.Message}."), cancellationToken); 
  
            // WaterfallStep always finishes with the end of the Waterfall or with another dialog, here it is the end. 
            return await stepContext.EndDialogAsync(cancellationToken: cancellationToken); 
        }

 _dialogs.Add(new TextPrompt("email", EmailPromptValidatorAsync));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private Task<bool> EmailPromptValidatorAsync(PromptValidatorContext<string> promptContext, CancellationToken cancellationToken) 
        { 
            var result = promptContext.Recognized.Value; 
  
            // This condition is our validation rule. 
            if (IsValidEmail(result)) 
            { 
                // Success is indicated by passing back the value the Prompt has collected. You must pass back a value even if you haven't changed it. 
                return Task.FromResult(true); 
            } 
  
            // Not calling End indicates validation failure. This will trigger a RetryPrompt if one has been defined. 
            return Task.FromResult(false); 
        } 
  
        private bool IsValidEmail(string source) 
        { 
            return new EmailAddressAttribute().IsValid(source); 
        }

1
2
3
4
  public Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken)) 
        { 
            throw new NotImplementedException(); 
        }

1
2
3
4
  if (turnContext == null) 
            { 
                throw new ArgumentNullException(nameof(turnContext)); 
            }

1
2
3
4
// Run the DialogSet - let the framework identify the current state of the dialog from 
            // the dialog stack and figure out what (if any) is the active dialog. 
            var dialogContext = await _dialogs.CreateContextAsync(turnContext, cancellationToken); 
            var results = await dialogContext.ContinueDialogAsync(cancellationToken);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Handle Message activity type, which is the main activity type for shown within a conversational interface 
            // Processes ConversationUpdate Activities to welcome the user. 
            if (turnContext.Activity.Type == ActivityTypes.ConversationUpdate) 
            { 
                if (turnContext.Activity.MembersAdded.Any()) 
                { 
                    foreach (var member in turnContext.Activity.MembersAdded) 
                    { 
                        if (member.Id != turnContext.Activity.Recipient.Id) 
                        { 
                            // Sends a welcome message to the user. 
                            await SendWelcomeMessageAsync(turnContext, cancellationToken); 
                            // Pushes a new dialog onto the dialog stack. 
                            await dialogContext.BeginDialogAsync("details", null, cancellationToken); 
                        } 
                    } 
                } 
            }

1
2
3
4
5
6
7
8
9
10
11
12
13
// Message activities may contain text, speech, interactive cards, and binary or unknown attachments. 
            // see <a href="https://aka.ms/about-bot-activity-message" target="_blank">https://aka.ms/about-bot-activity-message</a> to learn more about the message and other activity types 
            else if (turnContext.Activity.Type == ActivityTypes.Message) 
            { 
                // Continues execution of the active dialog, if there is one 
               var results = await dialogContext.ContinueDialogAsync(cancellationToken); 
  
                // If the DialogTurnStatus is Empty we should start a new dialog. 
                if(results.Status == DialogTurnStatus.Empty) 
                { 
                    await dialogContext.BeginDialogAsync("details", null, cancellationToken); 
                } 
            }

1
2
3
4
5
// Save the dialog state into the conversation state. 
            await _accessors.ConversationState.SaveChangesAsync(turnContext, false, cancellationToken); 
  
            // Save the  FeedbackData updates into the user state. 
            await _accessors.UserState.SaveChangesAsync(turnContext, false, cancellationToken);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken)) 
        { 
            if (turnContext == null) 
            { 
                throw new ArgumentNullException(nameof(turnContext)); 
            } 
  
            // Run the DialogSet - let the framework identify the current state of the dialog from 
            // the dialog stack and figure out what (if any) is the active dialog. 
            var dialogContext = await _dialogs.CreateContextAsync(turnContext, cancellationToken); 
  
            // Handle Message activity type, which is the main activity type for shown within a conversational interface 
            // Processes ConversationUpdate Activities to welcome the user. 
            if (turnContext.Activity.Type == ActivityTypes.ConversationUpdate) 
            { 
                if (turnContext.Activity.MembersAdded.Any()) 
                { 
                    foreach (var member in turnContext.Activity.MembersAdded) 
                    { 
                        if (member.Id != turnContext.Activity.Recipient.Id) 
                        { 
                            // Sends a welcome message to the user. 
                            await SendWelcomeMessageAsync(turnContext, cancellationToken); 
                            // Pushes a new dialog onto the dialog stack. 
                            await dialogContext.BeginDialogAsync("details", null, cancellationToken); 
                        } 
                    } 
                } 
            } 
  
            // Message activities may contain text, speech, interactive cards, and binary or unknown attachments. 
            // see <a href="https://aka.ms/about-bot-activity-message" target="_blank">https://aka.ms/about-bot-activity-message</a> to learn more about the message and other activity types 
            else if (turnContext.Activity.Type == ActivityTypes.Message) 
            { 
                // Continues execution of the active dialog, if there is one 
               var results = await dialogContext.ContinueDialogAsync(cancellationToken); 
  
                // If the DialogTurnStatus is Empty we should start a new dialog. 
                if(results.Status == DialogTurnStatus.Empty) 
                { 
                    await dialogContext.BeginDialogAsync("details", null, cancellationToken); 
                } 
            } 
  
            // Save the dialog state into the conversation state. 
            await _accessors.ConversationState.SaveChangesAsync(turnContext, false, cancellationToken); 
  
            // Save the  FeedbackData updates into the user state. 
            await _accessors.UserState.SaveChangesAsync(turnContext, false, cancellationToken); 
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
  
 public class RequestFeedbackDialog : IBot 
    { 
        private readonly BotAccessors _accessors; 
        private readonly ILogger _logger; 
  
        /// <summary> 
        /// The <see cref="DialogSet"/> that contains all the Dialogs that can be used at runtime. 
        /// </summary> 
        private DialogSet _dialogs; 
  
        public RequestFeedbackDialog(BotAccessors accessors, ILoggerFactory loggerFactory) 
        { 
  
            _accessors = accessors ?? throw new ArgumentNullException(nameof(accessors)); 
  
            if (loggerFactory == null) 
            { 
                throw new System.ArgumentNullException(nameof(loggerFactory)); 
            } 
  
  
            _logger = loggerFactory.CreateLogger<RequestFeedbackDialog>(); 
            _logger.LogTrace("RequestFeedbackDialogBot turn start."); 
  
            // The DialogSet needs a DialogState accessor, it will call it when it has a turn context. 
            _dialogs = new DialogSet(accessors.ConversationDialogState); 
  
            // This array defines how the Waterfall will execute. 
            var waterfallSteps = new WaterfallStep[] 
            { 
                RequestStepAsync, 
                NameStepAsync, 
                NameConfirmStepAsync, 
                EmailConfirmStepAsync, 
                SummaryStepAsync, 
            }; 
  
            // Add named dialogs to the DialogSet. These names are saved in the dialog state. 
            _dialogs.Add(new WaterfallDialog("details", waterfallSteps)); 
            _dialogs.Add(new ConfirmPrompt("confirm", defaultLocale: Culture.French)); 
            _dialogs.Add(new TextPrompt("nom")); 
            _dialogs.Add(new TextPrompt("email", EmailPromptValidatorAsync)); 
            _dialogs.Add(new TextPrompt("message")); 
        } 
  
        /// <summary> 
        /// Every conversation turn for our Bot will call 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"/> 
        /// <seealso cref="IMiddleware"/> 
        public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken)) 
        { 
            if (turnContext == null) 
            { 
                throw new ArgumentNullException(nameof(turnContext)); 
            } 
  
            // Run the DialogSet - let the framework identify the current state of the dialog from 
            // the dialog stack and figure out what (if any) is the active dialog. 
            var dialogContext = await _dialogs.CreateContextAsync(turnContext, cancellationToken); 
  
            // Handle Message activity type, which is the main activity type for shown within a conversational interface 
            // Processes ConversationUpdate Activities to welcome the user. 
            if (turnContext.Activity.Type == ActivityTypes.ConversationUpdate) 
            { 
                if (turnContext.Activity.MembersAdded.Any()) 
                { 
                    foreach (var member in turnContext.Activity.MembersAdded) 
                    { 
                        if (member.Id != turnContext.Activity.Recipient.Id) 
                        { 
                            // Sends a welcome message to the user. 
                            await SendWelcomeMessageAsync(turnContext, cancellationToken); 
                            // Pushes a new dialog onto the dialog stack. 
                            await dialogContext.BeginDialogAsync("details", null, cancellationToken); 
                        } 
                    } 
                } 
            } 
  
            // 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 
            else if (turnContext.Activity.Type == ActivityTypes.Message) 
            { 
                // Continues execution of the active dialog, if there is one 
               var results = await dialogContext.ContinueDialogAsync(cancellationToken); 
  
                // If the DialogTurnStatus is Empty we should start a new dialog. 
                if(results.Status == DialogTurnStatus.Empty) 
                { 
                    await dialogContext.BeginDialogAsync("details", null, cancellationToken); 
                } 
            } 
  
            // Save the dialog state into the conversation state. 
            await _accessors.ConversationState.SaveChangesAsync(turnContext, false, cancellationToken); 
  
            // Save the  FeedbackData updates into the user state. 
            await _accessors.UserState.SaveChangesAsync(turnContext, false, cancellationToken); 
        } 
  
        private static async Task SendWelcomeMessageAsync(ITurnContext turnContext, CancellationToken cancellationToken) 
        { 
  
            await turnContext.SendActivityAsync( 
        "Bienvenue. Ce bot permet de recueillir vos avis.", 
        cancellationToken: cancellationToken); 
  
        } 
  
        /// <summary> 
        /// One of the functions that make up the <see cref="WaterfallDialog"/>. 
        /// </summary> 
        /// <param name="stepContext">The <see cref="WaterfallStepContext"/> gives access to the executing dialog runtime.</param> 
        /// <param name="cancellationToken">A <see cref="CancellationToken"/>.</param> 
        /// <returns>A <see cref="DialogTurnResult"/> to communicate some flow control back to the containing WaterfallDialog.</returns> 
        private async Task<DialogTurnResult> RequestStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog. 
            return await stepContext.PromptAsync("confirm", new PromptOptions { Prompt = MessageFactory.Text("Voulez-vous nous laisser vos commentaires ?") }, cancellationToken); 
        } 
  
        /// <summary> 
        /// One of the functions that make up the <see cref="WaterfallDialog"/>. 
        /// </summary> 
        /// <param name="stepContext">The <see cref="WaterfallStepContext"/> gives access to the executing dialog runtime.</param> 
        /// <param name="cancellationToken">A <see cref="CancellationToken"/>.</param> 
        /// <returns>A <see cref="DialogTurnResult"/> to communicate some flow control back to the containing WaterfallDialog.</returns> 
        private async Task<DialogTurnResult> NameStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            if ((bool)stepContext.Result) 
            { 
                // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog. 
                // Running a prompt here means the next WaterfallStep will be run when the users response is received. 
                return await stepContext.PromptAsync("nom", new PromptOptions { Prompt = MessageFactory.Text("Veuillez saisir votre nom.") }, cancellationToken); 
            } 
            else 
            { 
                await stepContext.Context.SendActivityAsync(MessageFactory.Text("Merci. Aurevoir."), cancellationToken); 
                return await stepContext.EndDialogAsync(cancellationToken: cancellationToken); 
  
            } 
        } 
  
        /// <summary> 
        /// One of the functions that make up the <see cref="WaterfallDialog"/>. 
        /// </summary> 
        /// <param name="stepContext">The <see cref="WaterfallStepContext"/> gives access to the executing dialog runtime.</param> 
        /// <param name="cancellationToken">A <see cref="CancellationToken"/>.</param> 
        /// <returns>A <see cref="DialogTurnResult"/> to communicate some flow control back to the containing WaterfallDialog.</returns> 
        private async Task<DialogTurnResult> NameConfirmStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            // Get the current feedbackData object from user state. 
            var feedbackData = await _accessors.FeedbackData.GetAsync(stepContext.Context, () => new FeedbackData(), cancellationToken); 
  
            // Update the feedbackData. 
            feedbackData.Name = (string)stepContext.Result; 
  
            // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog. 
            return await stepContext.PromptAsync("email", new PromptOptions { Prompt = MessageFactory.Text("Veuillez saisir votre adresse email.") }, cancellationToken); 
        } 
  
        /// <summary> 
        /// One of the functions that make up the <see cref="WaterfallDialog"/>. 
        /// </summary> 
        /// <param name="stepContext">The <see cref="WaterfallStepContext"/> gives access to the executing dialog runtime.</param> 
        /// <param name="cancellationToken">A <see cref="CancellationToken"/>.</param> 
        /// <returns>A <see cref="DialogTurnResult"/> to communicate some flow control back to the containing WaterfallDialog.</returns> 
        private async Task<DialogTurnResult> EmailConfirmStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
            // Get the current feedbackData object from user state. 
            var feedbackData = await _accessors.FeedbackData.GetAsync(stepContext.Context, () => new FeedbackData(), cancellationToken); 
  
            // Update the feedbackData. 
            feedbackData.Email = (string)stepContext.Result; 
  
            // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog. 
            return await stepContext.PromptAsync("message", new PromptOptions { Prompt = MessageFactory.Text("Veuillez saisir votre message.") }, cancellationToken); 
        } 
  
        /// <summary> 
        /// One of the functions that make up the <see cref="WaterfallDialog"/>. 
        /// </summary> 
        /// <param name="stepContext">The <see cref="WaterfallStepContext"/> gives access to the executing dialog runtime.</param> 
        /// <param name="cancellationToken">A <see cref="CancellationToken"/>.</param> 
        /// <returns>A <see cref="DialogTurnResult"/> to communicate some flow control back to the containing WaterfallDialog.</returns> 
        private async Task<DialogTurnResult> SummaryStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) 
        { 
  
            // Get the current feedbackData object from user state. 
            var feedbackData = await _accessors.FeedbackData.GetAsync(stepContext.Context, () => new FeedbackData(), cancellationToken); 
  
            // Update the feedbackData. 
            feedbackData.Message = (string)stepContext.Result; 
  
            await stepContext.Context.SendActivityAsync(MessageFactory.Text($"Votre nom {feedbackData.Name}, votre email {feedbackData.Email} et votre message {feedbackData.Message}."), cancellationToken); 
  
            // WaterfallStep always finishes with the end of the Waterfall or with another dialog, here it is the end. 
            return await stepContext.EndDialogAsync(cancellationToken: cancellationToken); 
        } 
  
        /// <summary> 
        /// This is an example of a custom validator.  
        /// Returning true indicates the recognized value is acceptable. Returning false will trigger re-prompt behavior. 
        /// </summary> 
        /// <param name="promptContext">The <see cref="PromptValidatorContext"/> gives the validator code access to the runtime, including the recognized value and the turn context.</param> 
        /// <param name="cancellationToken">The cancellation token.</param> 
        /// <returns>A <see cref="Task"/> representing the operation result of the Turn operation.</returns> 
        private Task<bool> EmailPromptValidatorAsync(PromptValidatorContext<string> promptContext, CancellationToken cancellationToken) 
        { 
            var result = promptContext.Recognized.Value; 
  
            // This condition is our validation rule. 
            if (IsValidEmail(result)) 
            { 
                // Success is indicated by passing back the value the Prompt has collected. You must pass back a value even if you haven't changed it. 
                return Task.FromResult(true); 
            } 
  
            // Not calling End indicates validation failure. This will trigger a RetryPrompt if one has been defined. 
            return Task.FromResult(false); 
        } 
  
        private bool IsValidEmail(string source) 
        { 
            return new EmailAddressAttribute().IsValid(source); 
        } 
    }

services.AddBot<EchoWithCounterBot>

services.AddBot<RequestFeedbackDialog>

1
2
3
var conversationState = new ConversationState(dataStore); 
  
                options.State.Add(conversationState);

1
2
3
4
5
6
7
var conversationState = new ConversationState(dataStore); 
  
                options.State.Add(conversationState); 
  
                // Create and add user state. 
                var userState = new UserState(dataStore); 
                options.State.Add(userState);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
services.AddSingleton<EchoBotAccessors>(sp => 
            { 
                var options = sp.GetRequiredService<IOptions<BotFrameworkOptions>>().Value; 
                if (options == null) 
                { 
                    throw new InvalidOperationException("BotFrameworkOptions must be configured prior to setting up the state accessors"); 
                } 
  
                var conversationState = options.State.OfType<ConversationState>().FirstOrDefault(); 
                if (conversationState == null) 
                { 
                    throw new InvalidOperationException("ConversationState must be defined and added before adding conversation-scoped state accessors."); 
                } 
  
                // Create the custom state accessor. 
                // State accessors enable other components to read and write individual properties of state. 
                var accessors = new EchoBotAccessors(conversationState) 
                { 
                    CounterState = conversationState.CreateProperty<CounterState>(EchoBotAccessors.CounterStateName), 
                }; 
  
                return accessors; 
            });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
  
  services.AddSingleton<BotAccessors>(sp => 
            { 
                // We need to grab the conversationState we added on the options in the previous step 
                var options = sp.GetRequiredService<IOptions<BotFrameworkOptions>>().Value; 
                if (options == null) 
                { 
                    throw new InvalidOperationException("BotFrameworkOptions must be configured prior to setting up the State Accessors"); 
                } 
  
                var conversationState = options.State.OfType<ConversationState>().FirstOrDefault(); 
                if (conversationState == null) 
                { 
                    throw new InvalidOperationException("ConversationState must be defined and added before adding conversation-scoped state accessors."); 
                } 
  
                var userState = options.State.OfType<UserState>().FirstOrDefault(); 
                if (userState == null) 
                { 
                    throw new InvalidOperationException("UserState must be defined and added before adding user-scoped state accessors."); 
                } 
  
                // Create the custom state accessor. 
                // State accessors enable other components to read and write individual properties of state. 
                var accessors = new BotAccessors(conversationState, userState) 
                { 
                    ConversationDialogState = conversationState.CreateProperty<DialogState>("DialogState"), 
                    FeedbackData = userState.CreateProperty<FeedbackData>("FeedbackData"), 
                }; 
  
                return accessors; 
            });