Merge branch 'develop'

Author: msft-shahins

CSharp/Documentation/Forms.cs

@@ -13,7 +13,11 @@
     /// [EntityRecommendation.Entity]: @ref Microsoft.Bot.Builder.Luis.EntityRecommendation.Entity 
     /// [LuisDialog]: @ref Microsoft.Bot.Builder.Dialogs.LuisDialog 
     /// [AllowDefault]: @ref Advanced.TemplateBaseAttribute.AllowDefault 
+    /// [ChoiceCase]: @ref Advanvced.TemplateBaseAttribute.ChoiceCase
+    /// [ChoiceLastSeparator]: @ref Advanced.TemplateBaseAttribute.ChoiceLastSeparator
+    /// [ChoiceSeparator]: @ref Advanced.TemplateBaseAttribtue.ChoiceSeparator
     /// [ChoiceFormat]: @ref Advanced.TemplateBaseAttribute.ChoiceFormat 
+    /// [ChoiceParens]: @ref Advanced.TemplateBaseAttribute.ChoiceParens
     /// [ChoiceStyle]: @ref Advanced.TemplateBaseAttribute.ChoiceStyle 
     /// [Feedback]: @ref Advanced.TemplateBaseAttribute.Feedback 
     /// [FieldCase]: @ref Advanced.TemplateBaseAttribute.FieldCase 
@@ -414,7 +418,7 @@
     /// ~~~{.txt}
     /// What kind of sandwich would you like?
     /// > ?
-    /// * You are filling in the sandwich field.Possible responses:
+    /// * You are filling in the sandwich field. Possible responses:
     /// * You can enter in any words from the descriptions. (BLT, Black Forest Ham, Buffalo Chicken, Chicken And Bacon Ranch Melt, Cold Cut Combo, Meatball Marinara, Over Roasted Chicken, Roast Beef, Rotisserie Style Chicken, Spicy Italian, Steak And Cheese, Sweet Onion Teriyaki, Tuna, Turkey Breast, and Veggie)
     /// * Back: Go back to the previous question.
     /// * Help: Show the kinds of responses you can enter.
@@ -720,12 +724,16 @@
     /// Usage | Description
     /// ------|------------
     /// [AllowDefault] | When processing choices using {\|\|} controls whether the current value should be showed as a choice.
-    /// [ChoiceFormat] | When processing choices using {\|\|} controls how each choice is formatted. {0} is the choice number and {1} the choice description.
+    /// [ChoiceCase] | When prcoessing choices for {\|\|} controls case normalization for each choice.
+    /// [ChoiceFormat] | When processing choices for {\|\|} controls how each choice is formatted. {0} is the choice number and {1} the choice description.
+    /// [ChoiceLastSeparator] | When inline choice lists are constructed for {\|\|} provides the separator before the last choice.
+    /// [ChoiceParens] | When inline choice lists are constructed for {\|\|} indicates whether or not they are in parentheses.
+    /// [ChoiceSeparator] | When inline choice lists are constructed for {\|\|} provides the separaotr before every choice except the last.
     /// [ChoiceStyle] | When processing choices using {\|\|} controls whether the choices are presented in line or per line.
     /// [Feedback] | For [Prompt] only controls feedback after user entry.
     /// [FieldCase] | Controls case normalization when displaying a field description.
-    /// [LastSeparator] | When lists are constructed for {[]} or in line choices from {\|\|} provides the separator before the last item.
-    /// [Separator] | When lists are constructed for {[]} or in line choices from {\|\|} provides the separator before every item except the last.
+    /// [LastSeparator] | When lists are constructed for {[]} provides the separator before the last item.
+    /// [Separator] | When lists are constructed for {[]} provides the separator before every item except the last.
     /// [ValueCase] | Controls case normalization when displaying a field value.
     /// 
 }

CSharp/Library/Dialogs/BotToUser.cs

@@ -1,20 +1,55 @@
-using Microsoft.Bot.Builder.Internals.Fibers;
-using Microsoft.Bot.Connector;
+// 
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license.
+// 
+// Microsoft Bot Framework: http://botframework.com
+// 
+// Bot Builder SDK Github:
+// https://github.com/Microsoft/BotBuilder
+// 
+// Copyright (c) Microsoft Corporation
+// All rights reserved.
+// 
+// MIT License:
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Collections;
+
+using Microsoft.Bot.Builder.Internals.Fibers;
+using Microsoft.Bot.Connector;
 
 namespace Microsoft.Bot.Builder.Dialogs.Internals
 {
-    public sealed class ReactiveBotToUser : IBotToUser
+    public sealed class SendLastInline_BotToUser : IBotToUser
     {
         private readonly Message toBot;
         private readonly IConnectorClient client;
-        public ReactiveBotToUser(Message toBot, IConnectorClient client)
+        public SendLastInline_BotToUser(Message toBot, IConnectorClient client)
         {
             SetField.NotNull(out this.toBot, nameof(toBot), toBot);
             SetField.NotNull(out this.client, nameof(client), client);
@@ -95,4 +130,26 @@ async Task IBotToUser.PostAsync(Message message, CancellationToken cancellationT
             this.queue.Enqueue(message);
         }
     }
+
+    public sealed class BotToUserTextWriter : IBotToUser
+    {
+        private readonly IBotToUser inner;
+        private readonly TextWriter writer;
+        public BotToUserTextWriter(IBotToUser inner, TextWriter writer)
+        {
+            SetField.NotNull(out this.inner, nameof(inner), inner);
+            SetField.NotNull(out this.writer, nameof(writer), writer);
+        }
+
+        Message IBotToUser.MakeMessage()
+        {
+            return this.inner.MakeMessage();
+        }
+
+        async Task IBotToUser.PostAsync(Message message, CancellationToken cancellationToken)
+        {
+            await this.inner.PostAsync(message, cancellationToken);
+            await this.writer.WriteLineAsync(message.Text);
+        }
+    }
 }

CSharp/Library/Dialogs/Chain.cs

@@ -103,6 +103,30 @@ public static IDialog<R> ContinueWith<T, R>(this IDialog<T> antecedent, Continut
             return new ContinueWithDialog<T, R>(antecedent, continuation);
         }
 
+        /// <summary>
+        /// When the antecedent <see cref="IDialog{T}"/> has completed, project the result into a new <see cref="IDialog{R}"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the antecedent dialog.</typeparam>
+        /// <typeparam name="R">The type of the projected dialog.</typeparam>
+        /// <param name="antecedent">The antecedent dialog <see cref="IDialog{T}"/>.</param>
+        /// <param name="selector">The projection function from <typeparamref name="T"/> to <typeparamref name="R"/>.</param>
+        /// <returns>The result <see cref="IDialog{R}"/>.</returns>
+        public static IDialog<R> Select<T, R>(this IDialog<T> antecedent, Func<T, R> selector)
+        {
+            return new SelectDialog<T, R>(antecedent, selector);
+        }
+
+        /// <summary>
+        /// When the antecedent <see cref="IDialog{IDialog{T}}"/> has completed, unwrap the result into a new <see cref="IDialog{T}"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the antecedent dialog.</typeparam>
+        /// <param name="antecedent">The antecedent dialog <see cref="IDialog{IDialog{T}}"/>.</param>
+        /// <returns>The result <see cref="IDialog{T}"/>.</returns>
+        public static IDialog<T> Unwrap<T>(this IDialog<IDialog<T>> antecedent)
+        {
+            return new UnwrapDialog<T>(antecedent);
+        }
+
         /// <summary>
         /// When the antecedent <see cref="IDialog{T}"/> has completed, execute the next <see cref="IDialog{C}"/>, and use the projection to combine the results.
         /// </summary>
@@ -123,9 +147,9 @@ public static IDialog<R> SelectMany<T, C, R>(this IDialog<T> antecedent, Func<T,
         /// </summary>
         /// <param name="antecedent">The antecedent <see cref="IDialog"/>.</param>
         /// <returns>The looping dialog.</returns>
-        public static IDialog Loop(this IDialog antecedent)
+        public static IDialog<T> Loop<T>(this IDialog<T> antecedent)
         {
-            return new LoopDialog(antecedent);
+            return new LoopDialog<T>(antecedent);
         }
 
         [Serializable]
@@ -136,7 +160,7 @@ public FromDialog(Func<IDialog<T>> MakeDialog)
             {
                 SetField.NotNull(out this.MakeDialog, nameof(MakeDialog), MakeDialog);
             }
-            async Task IDialog.StartAsync(IDialogContext context)
+            async Task IDialog<T>.StartAsync(IDialogContext context)
             {
                 var dialog = this.MakeDialog();
                 context.Call<T>(dialog, ResumeAsync);
@@ -157,7 +181,7 @@ public DoDialog(IDialog<T> antecedent, Action<IAwaitable<T>> Action)
                 SetField.NotNull(out this.Antecedent, nameof(antecedent), antecedent);
                 SetField.NotNull(out this.Action, nameof(Action), Action);
             }
-            async Task IDialog.StartAsync(IDialogContext context)
+            async Task IDialog<T>.StartAsync(IDialogContext context)
             {
                 context.Call<T>(this.Antecedent, ResumeAsync);
             }
@@ -176,7 +200,7 @@ public PostToUserDialog(IDialog<T> antecedent)
             {
                 SetField.NotNull(out this.Antecedent, nameof(antecedent), antecedent);
             }
-            async Task IDialog.StartAsync(IDialogContext context)
+            async Task IDialog<T>.StartAsync(IDialogContext context)
             {
                 context.Call<T>(this.Antecedent, ResumeAsync);
             }
@@ -198,7 +222,7 @@ public ContinueWithDialog(IDialog<T> antecedent, Continutation<T, R> continuatio
                 SetField.NotNull(out this.Antecedent, nameof(antecedent), antecedent);
                 SetField.NotNull(out this.Continuation, nameof(continuation), continuation);
             }
-            async Task IDialog.StartAsync(IDialogContext context)
+            async Task IDialog<R>.StartAsync(IDialogContext context)
             {
                 context.Call<T>(this.Antecedent, ResumeAsync);
             }
@@ -213,6 +237,52 @@ private async Task DoneAsync(IDialogContext context, IAwaitable<R> result)
             }
         }
 
+        [Serializable]
+        private sealed class SelectDialog<T, R> : IDialog<R>
+        {
+            public readonly IDialog<T> Antecedent;
+            public readonly Func<T, R> Selector;
+            public SelectDialog(IDialog<T> antecedent, Func<T, R> selector)
+            {
+                SetField.NotNull(out this.Antecedent, nameof(antecedent), antecedent);
+                SetField.NotNull(out this.Selector, nameof(selector), selector);
+            }
+            async Task IDialog<R>.StartAsync(IDialogContext context)
+            {
+                context.Call<T>(this.Antecedent, AfterAntecedent);
+            }
+            private async Task AfterAntecedent(IDialogContext context, IAwaitable<T> result)
+            {
+                var itemT = await result;
+                var itemR = this.Selector(itemT);
+                context.Done(itemR);
+            }
+        }
+
+        [Serializable]
+        private sealed class UnwrapDialog<T> : IDialog<T>
+        {
+            public readonly IDialog<IDialog<T>> Antecedent;
+            public UnwrapDialog(IDialog<IDialog<T>> antecedent)
+            {
+                SetField.NotNull(out this.Antecedent, nameof(antecedent), antecedent);
+            }
+            async Task IDialog<T>.StartAsync(IDialogContext context)
+            {
+                context.Call<IDialog<T>>(this.Antecedent, AfterAntecedent);
+            }
+            private async Task AfterAntecedent(IDialogContext context, IAwaitable<IDialog<T>> result)
+            {
+                var dialogT = await result;
+                context.Call<T>(dialogT, AfterDialog);
+            }
+            private async Task AfterDialog(IDialogContext context, IAwaitable<T> result)
+            {
+                var itemT = await result;
+                context.Done(itemT);
+            }
+        }
+
         // http://blogs.msdn.com/b/pfxteam/archive/2013/04/03/tasks-monads-and-linq.aspx
         [Serializable]
         private sealed class SelectManyDialog<T, C, R> : IDialog<R>
@@ -226,7 +296,7 @@ public SelectManyDialog(IDialog<T> antecedent, Func<T, IDialog<C>> function, Fun
                 SetField.NotNull(out this.Function, nameof(function), function);
                 SetField.NotNull(out this.Projection, nameof(projection), projection);
             }
-            async Task IDialog.StartAsync(IDialogContext context)
+            async Task IDialog<R>.StartAsync(IDialogContext context)
             {
                 context.Call<T>(this.Antecedent, AfterAntecedent);
             }
@@ -246,20 +316,20 @@ private async Task AfterFunction(IDialogContext context, IAwaitable<C> result)
         }
 
         [Serializable]
-        private sealed class LoopDialog : IDialog
+        private sealed class LoopDialog<T> : IDialog<T>
         {
-            public readonly IDialog Antecedent;
-            public LoopDialog(IDialog antecedent)
+            public readonly IDialog<T> Antecedent;
+            public LoopDialog(IDialog<T> antecedent)
             {
                 SetField.NotNull(out this.Antecedent, nameof(antecedent), antecedent);
             }
-            async Task IDialog.StartAsync(IDialogContext context)
+            async Task IDialog<T>.StartAsync(IDialogContext context)
             {
-                context.Call<object>(this.Antecedent, ResumeAsync);
+                context.Call<T>(this.Antecedent, ResumeAsync);
             }
-            private async Task ResumeAsync(IDialogContext context, IAwaitable<object> ignored)
+            private async Task ResumeAsync(IDialogContext context, IAwaitable<T> ignored)
             {
-                context.Call<object>(this.Antecedent, ResumeAsync);
+                context.Call<T>(this.Antecedent, ResumeAsync);
             }
         }
     }