Cómo llamar a FormFlow cuando el usuario seleccione una opción del quickreply en conversacional

Estoy creando una conversacional para el estacionamiento.

Cuando inicio menú de chat apego apper con el botón 3. Al hacer clic en primer botón mostrará quickreply con algunas opciones. Cuando el usuario elija primera opción Quiero empezar el FormFlow para la opción 1, a continuación, cuando el usuario elige la opción 2 inicio de nuevo este FormFlow.

Tengo adjuntar mi código, ¿podría por favor me ayude.

Aquí está el código para messagecontroller.cs:

namespace Project1
using System;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http;
using Autofac;
using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Builder.Dialogs.Internals;
using Microsoft.Bot.Connector;
using Properties;
using Dialogs;
using Microsoft.Bot.Builder.FormFlow;
using Microsoft.Bot.Builder.Dialogs;
using FormFlow;
using Models;

[BotAuthentication]
public class MessagesController : ApiController {
    private IMessageActivity activity;

    public string cityRange{
        get;
        private set;
    }

    private static IForm<Enquiry> buildEnquiryForm() {
        var builder = new FormBuilder<Enquiry>();

        public async Task<HttpResponseMessage> Post([FromBody]Activity activity){
            if (activity.Type == ActivityTypes.Message){

                // The Configured IISExpressSSLPort property in this project file

                const int ConfiguredHttpsPort = 44371;

                var link = Url.Link(CheckOut, new{ controller = CheckOut, action = Index });
                var uriBuilder = new UriBuilder(link){
                    Scheme = Uri.UriSchemeHttps,
                    Port = ConfiguredHttpsPort
                };
                var checkOutRouteUri = uriBuilder.Uri.ToString();

                using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, activity)){
                    var dialog = scope.Resolve<IDialog<object>>(TypedParameter.From(checkOutRouteUri));
                    await Conversation.SendAsync(activity, () = > dialog);
                }
            }
            else{
                await this.HandleSystemMessage(activity);
            }

            var response = Request.CreateResponse(HttpStatusCode.OK);
            return response;
        }

        internal static IDialog<ContactMessage> dialog(){
            return Chain.From(() = > FormDialog.FromForm(ContactMessage.BuildForm));
        }


        private async Task HandleSystemMessage(Activity message){
            if (message.Type == ActivityTypes.DeleteUserData){
                // Implement user deletion here
                // If we handle user deletion, return a real message
            }
            else if (message.Type == ActivityTypes.ConversationUpdate){
                if (message.MembersAdded.Any(o = > o.Id == message.Recipient.Id)){
                    var reply = message.CreateReply(Resources.RootDialog_Welcome_Message);

                    ConnectorClient connector = new ConnectorClient(new Uri(message.ServiceUrl));

                    await connector.Conversations.ReplyToActivityAsync(reply);
                }
            }
            else if (message.Type == ActivityTypes.ContactRelationUpdate){}

            else if (message.Type == cityRange && cityRange == A){
                await Conversation.SendAsync(activity, () = > new FormFlow.Enquiry());
            }

            else if (message.Type == ActivityTypes.Typing){
                // Handle knowing tha the user is typing
            }
            else if (message.Type == ActivityTypes.Ping) {}
        }
    }
}

ContactMessage es:

using Microsoft.Bot.Builder.FormFlow;
using System;
using Microsoft.Bot.Builder.Dialogs;
using System.Threading.Tasks;

namespace Project1.Models{
    [Serializable]
    public class ContactMessage{
        public string Name{
            get;
            set;
        }
        public string Address{
            get;
            set;
        }
        public string ContactNumber{
            get;
            set;
        }
        public string Email{
            get;
            set; 
        }
        public ContactMethod PreferredContactMethod{
            get;
            set;
        }
        public string Message{
            get;
            set;
        }

        public static IForm<ContactMessage> BuildForm(){
            return new FormBuilder<ContactMessage>()
            .Message(I just need a few details to submit your message)
            .Build();
        }
    }

    public enum ContactMethod{
        IGNORE,
        Telephone,
        SMS,
        Email
    }
}

Quiero llamar a la forma en esta parte de mi código en Rootdialog.cs:

private async Task WelcomeMessageAsync(IDialogContext context){
    var reply = context.MakeMessage();

    var options = new[] {
        Resources.RootDialog_Welcome_Start,
        Resources.RootDialog_Welcome_Stop,
    };
    reply.AddHeroCard(
        Resources.RootDialog_Welcome_Title,
        Resources.RootDialog_Welcome_Subtitle,
        options,
        new[] {  }
    );

    await context.PostAsync(reply);

    context.Wait(this.OnOptionSelected);
}

private async Task OnOptionSelected(IDialogContext context, IAwaitable<IMessageActivity> result){
    var message = await result;

    //if you choose start parking
    if (message.Text == Resources.RootDialog_Welcome_Start) {
        this.order = new Models.Order();

        var promptOptions = new PromptOptions<string>(
            Please select the city where you want to park:,
            options: new[] { A, B, C },
            promptStyler : new FacebookQuickRepliesPromptStyler()
        );

        PromptDialog.Choice(context, this.ResumeAfterSelection, promptOptions);

    }

    else if (message.Text == Resources.RootDialog_Welcome_Stop){}
}

private async Task ResumeAfterSelection(IDialogContext context, IAwaitable<string> result){
    try {
        var cityRange = await result;
        if (cityRange == A){

            //  **I WANT TO CALL HERE MY FORMFLOW**  


            //  context.Call(FormDialog.FromForm<Enquiry>(Enquiry.BuildEnquiryForm, FormOptions.PromptInStart), async (ctx, formResult) => ctx.Wait(this.MessageReceivedAsync));

            //  var myform = new FormDialog<Enquiry>(new Enquiry(), Enquiry.BuildEnquiryForm, FormOptions.PromptInStart, null);

            //  context.Call(myform, ResumeAfterCallback);
            //// Chain.From(() => new Enquiry(buildEnquiryForm));

            //var orderForm = new FormDialog<Models.Order>(this.order, Models.Order.BuildOrderForm, FormOptions.PromptInStart);
            //context.Call(orderForm, this.AfterOrderForm);
            // }

            //   await Conversation.SendAsync(activity, Enquiry);

            Chain.From(() = > FormDialog.FromForm(ContactMessage.BuildForm));