C# 如何将DbContext（或任何其他对象）注入对话框？

假设在本例中我想将订单保存到数据库

我可以将DbConext注入控制器，例如这一个，但如何在

我不能只是将DbContext作为构造函数参数传递给PizzaOrderDialog类，因为PizzaOrderDialog对象将被序列化然后反序列化

最好的方法是什么？提前谢谢

---

MessageController.cs

[BotAuthentication]
public class MessagesController : ApiController
{
    private static IForm<PizzaOrder> BuildForm()
    {
        var builder = new FormBuilder<PizzaOrder>();

        ConditionalDelegate<PizzaOrder> isBYO = (pizza) => pizza.Kind == PizzaOptions.BYOPizza;
        ConditionalDelegate<PizzaOrder> isSignature = (pizza) => pizza.Kind == PizzaOptions.SignaturePizza;
        ConditionalDelegate<PizzaOrder> isGourmet = (pizza) => pizza.Kind == PizzaOptions.GourmetDelitePizza;
        ConditionalDelegate<PizzaOrder> isStuffed = (pizza) => pizza.Kind == PizzaOptions.StuffedPizza;

        return builder
            // .Field(nameof(PizzaOrder.Choice))
            .Field(nameof(PizzaOrder.Size))
            .Field(nameof(PizzaOrder.Kind))
            .Field("BYO.Crust", isBYO)
            .Field("BYO.Sauce", isBYO)
            .Field("BYO.Toppings", isBYO)
            .Field(nameof(PizzaOrder.GourmetDelite), isGourmet)
            .Field(nameof(PizzaOrder.Signature), isSignature)
            .Field(nameof(PizzaOrder.Stuffed), isStuffed)
            .AddRemainingFields()
            .Confirm("Would you like a {Size}, {BYO.Crust} crust, {BYO.Sauce}, {BYO.Toppings} pizza?", isBYO)
            .Confirm("Would you like a {Size}, {&Signature} {Signature} pizza?", isSignature, dependencies: new string[] { "Size", "Kind", "Signature" })
            .Confirm("Would you like a {Size}, {&GourmetDelite} {GourmetDelite} pizza?", isGourmet)
            .Confirm("Would you like a {Size}, {&Stuffed} {Stuffed} pizza?", isStuffed)
            .Build()
            ;
    }

    internal static IDialog MakeRoot()
    {
        return new PizzaOrderDialog(BuildForm);
    }

    public async Task<Message> Post([FromBody]Message message)
    {
        return await Conversation.SendAsync(message, MakeRoot);
    }
}

[BotAuthentication]
公共类消息控制器：ApiController
{
私有静态格式BuildForm（）
{
var builder=new FormBuilder（）；
ConditionalDelegate isBYO=（pizza）=>pizza.Kind==PizzaOptions.BYOPizza；
ConditionalDelegate isSignature=（pizza）=>pizza.Kind==PizzaOptions.SignaturePizza；
ConditionalDelegate是Gourmet=（pizza）=>pizza.Kind==PizzaOptions.GourmetDelitePizza；
ConditionalDelegate isStuffed=（pizza）=>pizza.Kind==PizzaOptions.StuffedPizza；
返回生成器
//.Field（名称（PizzaOrder.Choice））
.字段（名称（比萨饼订单.大小））
.字段（名称（比萨饼订单.种类））
.Field（“BYO.地壳”，isBYO）
.Field（“BYO.Sauce”，isBYO）
.Field（“BYO.Toppings”，isBYO）
.Field（名称为（PizzaOrder.GourmetDelite），isGourmet）
.Field（名称（PizzaOrder.Signature），isSignature）
.Field（名称（PizzaOrder.fulled），isStuffed）
.AddRemainingFields（）
.确认（“您想要{Size}、{BYO.地壳}地壳、{BYO.沙司}、{BYO.配料}比萨饼吗？”，isBYO）
.Confirm（“您想要一个{Size}，{&Signature}{Signature}比萨饼吗？”，isSignature，dependencies:新字符串[]{“Size”，“Kind”，“Signature”}）
.确认（“您想要一个{Size}，{GourmetDelite}{GourmetDelite}比萨饼吗？”，isGourmet）
.确认（“您想要一个{Size}，{chicked}{chicked}比萨饼吗？”，isStuffed）
.Build（）
;
}
内部静态IDialog MakeRoot（）
{
返回新的PizzaOrderDialog（BuildForm）；
}
公共异步任务发布（[FromBody]消息）
{
返回wait Conversation.sendaync（消息，MakeRoot）；
}
}

---

PizzaOrderDialog.cs

[LuisModel("4311ccf1-5ed1-44fe-9f10-a6adbad05c14", "6d0966209c6e4f6b835ce34492f3e6d9")]
[Serializable]
public class PizzaOrderDialog : LuisDialog
{
    private readonly BuildForm<PizzaOrder> MakePizzaForm;

    internal PizzaOrderDialog(BuildForm<PizzaOrder> makePizzaForm)
    {
        this.MakePizzaForm = makePizzaForm;
    }

    [LuisIntent("")]
    public async Task None(IDialogContext context, LuisResult result)
    {
        await context.PostAsync("I'm sorry. I didn't understand you.");
        context.Wait(MessageReceived);
    }

    [LuisIntent("OrderPizza")]
    [LuisIntent("UseCoupon")]
    public async Task ProcessPizzaForm(IDialogContext context, LuisResult result)
    {
        var entities = new List<EntityRecommendation>(result.Entities);
        if (!entities.Any((entity) => entity.Type == "Kind"))
        {
            // Infer kind
            foreach (var entity in result.Entities)
            {
                string kind = null;
                switch (entity.Type)
                {
                    case "Signature": kind = "Signature"; break;
                    case "GourmetDelite": kind = "Gourmet delite"; break;
                    case "Stuffed": kind = "stuffed"; break;
                    default:
                        if (entity.Type.StartsWith("BYO")) kind = "byo";
                        break;
                }
                if (kind != null)
                {
                    entities.Add(new EntityRecommendation("Kind") { Entity = kind });
                    break;
                }
            }
        }

        var pizzaForm = new FormDialog<PizzaOrder>(new PizzaOrder(), this.MakePizzaForm, FormOptions.PromptInStart, entities);
        context.Call<PizzaOrder>(pizzaForm, PizzaFormComplete);
    }

    private async Task PizzaFormComplete(IDialogContext context, IAwaitable<PizzaOrder> result)
    {
        PizzaOrder order = null;
        try
        {
            order = await result;
        }
        catch (OperationCanceledException)
        {
            await context.PostAsync("You canceled the form!");
            return;
        }

        if (order != null)
        {
            await context.PostAsync("Your Pizza Order: " + order.ToString());
        }
        else
        {
            await context.PostAsync("Form returned empty response!");
        }

        context.Wait(MessageReceived);
    }

    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };

    [LuisIntent("StoreHours")]
    public async Task ProcessStoreHours(IDialogContext context, LuisResult result)
    {
        var days = (IEnumerable<Days>)Enum.GetValues(typeof(Days));

        PromptDialog.Choice(context, StoreHoursResult, days, "Which day of the week?");
    }

    private async Task StoreHoursResult(IDialogContext context, IAwaitable<Days> day)
    {
        var hours = string.Empty;
        switch (await day)
        {
            case Days.Saturday:
            case Days.Sunday:
                hours = "5pm to 11pm";
                break;
            default:
                hours = "11am to 10pm";
                break;
        }

        var text = $"Store hours are {hours}";
        await context.PostAsync(text);

        context.Wait(MessageReceived);
    }
}

[LuisModel（“4311ccf1-5ed1-44fe-9f10-a6adbad05c14”，“6D0966209C6E4F6B835CE3449F3E6D9”）]
[可序列化]
公共类PizzaOrderDialog:LuisDialog
{
私有只读BuildForm MakePizzaForm；
内部PizzaOrderDialog（BuildForm makePizzaForm）
{
this.MakePizzaForm=MakePizzaForm；
}
[路易辛顿（“”）
公共异步任务无（IDialogContext上下文，LuisResult结果）
{
等待上下文。PostAsync（“对不起，我没听懂你的意思。”）；
Wait（MessageReceived）；
}
[路易辛顿（“订购比萨饼”）]
[LuisIntent（“使用优惠券”）]
公共异步任务进程PizzaForm（IDialogContext上下文，LuisResult结果）
{
var实体=新列表（结果实体）；
如果（！entities.Any（（entity）=>entity.Type==“种类”））
{
//推断种类
foreach（result.Entities中的var实体）
{
字符串种类=null；
开关（实体类型）
{
案例“签名”：kind=“签名”；中断；
案例“GourmetDelite”：kind=“GourmetDelite”；中断；
案例“填充”：种类=“填充”中断；
违约：
if（entity.Type.StartsWith（“BYO”））kind=“BYO”；
打破
}
如果（种类！=null）
{
添加（新的EntityRecommendation（“种类”）{Entity=Kind}）；
打破
}
}
}
var pizzaForm=new FormDialog（new PizzaOrder（），this.MakePizzaForm，FormOptions.PromptInStart，entities）；
调用（pizzaForm，PizzaFormComplete）；
}
专用异步任务PizzaFormComplete（IDialogContext上下文，IAwaitable结果）
{
PizzaOrder=null；
尝试
{
订单=等待结果；
}
捕获（操作取消异常）
{
wait context.PostAsync（“您取消了表单！”）；
返回；
}
如果（订单！=null）
{
wait context.PostAsync（“您的比萨饼订单：+Order.ToString（））；
}
其他的
{
wait context.PostAsync（“表单返回空响应！”）；
}
Wait（MessageReceived）；
}
枚举日{星期六、星期日、星期一、星期二、星期三、星期四、星期五}；
[路易辛顿（“存储时间”）]
公共异步任务ProcessStoreHours（IDialogContext上下文，LuisResult结果）
{
var days=（IEnumerable）Enum.GetValues（typeof（days））；
选项（上下文、StoreHoursResult、天，“一周中的哪一天？”）；
}
专用异步任务StoreHoursResult（IDialogContext上下文，IAwaitable day）
{
var hours=string.Empty；
开关（等待日）
{
案件日。星期六：
案件日。星期日：
小时数=“下午5点至11点”；
打破
违约：
小时数=“上午11时至晚上10时”；
打破
}
var text=$“存储时间为{hours}”；
等待上下文。PostAsync（文本）；
Wait（MessageReceived）；
}
}

您请求执行的操作违反了MVC范式

也就是说，您不应该执行某些控制器类型的功能&在表示（视图）层（即PizzaOrderDialog.cs）的代码中直接与db模型交互

[LuisModel("4311ccf1-5ed1-44fe-9f10-a6adbad05c14", "6d0966209c6e4f6b835ce34492f3e6d9")]
[Serializable]
public class PizzaOrderDialog : LuisDialog
{
    private readonly BuildForm<PizzaOrder> MakePizzaForm;

    internal PizzaOrderDialog(BuildForm<PizzaOrder> makePizzaForm)
    {
        this.MakePizzaForm = makePizzaForm;
    }

    [LuisIntent("")]
    public async Task None(IDialogContext context, LuisResult result)
    {
        await context.PostAsync("I'm sorry. I didn't understand you.");
        context.Wait(MessageReceived);
    }

    [LuisIntent("OrderPizza")]
    [LuisIntent("UseCoupon")]
    public async Task ProcessPizzaForm(IDialogContext context, LuisResult result)
    {
        var entities = new List<EntityRecommendation>(result.Entities);
        if (!entities.Any((entity) => entity.Type == "Kind"))
        {
            // Infer kind
            foreach (var entity in result.Entities)
            {
                string kind = null;
                switch (entity.Type)
                {
                    case "Signature": kind = "Signature"; break;
                    case "GourmetDelite": kind = "Gourmet delite"; break;
                    case "Stuffed": kind = "stuffed"; break;
                    default:
                        if (entity.Type.StartsWith("BYO")) kind = "byo";
                        break;
                }
                if (kind != null)
                {
                    entities.Add(new EntityRecommendation("Kind") { Entity = kind });
                    break;
                }
            }
        }

        var pizzaForm = new FormDialog<PizzaOrder>(new PizzaOrder(), this.MakePizzaForm, FormOptions.PromptInStart, entities);
        context.Call<PizzaOrder>(pizzaForm, PizzaFormComplete);
    }

    private async Task PizzaFormComplete(IDialogContext context, IAwaitable<PizzaOrder> result)
    {
        PizzaOrder order = null;
        try
        {
            order = await result;
        }
        catch (OperationCanceledException)
        {
            await context.PostAsync("You canceled the form!");
            return;
        }

        if (order != null)
        {
            await context.PostAsync("Your Pizza Order: " + order.ToString());
        }
        else
        {
            await context.PostAsync("Form returned empty response!");
        }

        context.Wait(MessageReceived);
    }

    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };

    [LuisIntent("StoreHours")]
    public async Task ProcessStoreHours(IDialogContext context, LuisResult result)
    {
        var days = (IEnumerable<Days>)Enum.GetValues(typeof(Days));

        PromptDialog.Choice(context, StoreHoursResult, days, "Which day of the week?");
    }

    private async Task StoreHoursResult(IDialogContext context, IAwaitable<Days> day)
    {
        var hours = string.Empty;
        switch (await day)
        {
            case Days.Saturday:
            case Days.Sunday:
                hours = "5pm to 11pm";
                break;
            default:
                hours = "11am to 10pm";
                break;
        }

        var text = $"Store hours are {hours}";
        await context.PostAsync(text);

        context.Wait(MessageReceived);
    }
}

您应该将对db_上下文的单例引用注入控制器（您已经得到了该部分）

和

在控制器中添加函数以封装对话框的这些db_上下文交互，然后像现在一样注入这些函数的结果