Entity framework 在实体框架中构建堆栈_Entity Framework_Stack

Entity framework 在实体框架中构建堆栈

entity-framework

Entity framework 在实体框架中构建堆栈,entity-framework,stack,Entity Framework,Stack,我模型中的一种实体类型（我们称之为E1）需要能够将其与另一种实体类型（E2）的关系视为堆栈。反过来，该另一实体需要能够看到E2位于堆栈顶部的第一种类型的所有相关实体，以及E2位于E1堆栈内的每种情况我觉得这听起来不太清楚，所以让我试着证明： E1实体：foo{stack:quox，plugh，glurp}，bar{stack:plugh，glurp}，baz{stack:quox，plugh} E2实体：quux{top:null；in:foo，baz}，plugh{top:baz；in:fo

我模型中的一种实体类型（我们称之为E1）需要能够将其与另一种实体类型（E2）的关系视为堆栈。反过来，该另一实体需要能够看到E2位于堆栈顶部的第一种类型的所有相关实体，以及E2位于E1堆栈内的每种情况

我觉得这听起来不太清楚，所以让我试着证明：

E1实体：foo{stack:quox，plugh，glurp}，bar{stack:plugh，glurp}，baz{stack:quox，plugh}

E2实体：quux{top:

null

；in:foo，baz}，plugh{top:baz；in:foo，baz}，glurp{top:bar；in:foo，bar}

现在，我有一个数据库表，其中包含E1和E2键的列，以及用于存储E2在堆栈中位置的int。实体框架将此表视为其自己的实体，而不是E1和E2之间关系的一部分，这会使查询复杂化，并导致一些非常难看的代码

我知道我做错了，但有可能做对吗？如果是这样，怎么做？

因此，如果我们调用关系表R，每个E1“包含”多个R（它是堆栈，按R.position排序），每个E2以两种方式包含多个R：R.position==R.E1.top的和不包含的）

对吗
你是如何追踪最高层的？当堆栈发生变化时（例如E1.top为常数），您是否更新E1的所有Rs，还是将其存储在每个E1中
将Rs链接起来（给他们一个“下一个指针”而不是“位置”）有意义吗
您需要随机访问堆栈吗
E2真的需要知道他们不在顶端的情况吗

public partial class E1
{
   public Guid Id { get; set; }
   public IQueryable<E1E2> Stack { get; }
}

public partial class E2
{
   public Guid Id { get; set; }
   public IQueryable<E1E2> In { get; }
}

public partial class E1E2
{
   public E1 E1 { get; set; }
   public E2 E2 { get; set; }
   public Int32 Position { get; set; }
}

公共部分类E1
{
公共Guid Id{get；set；}
公共IQueryable堆栈{get；}
}
公共部分类E2
{
公共Guid Id{get；set；}
{get；}中的公共IQueryable
}
公共部分类E1E2
{
公共e1e1{get；set；}
公共E2 E2{get；set；}
公共Int32位置{get；set；}
}

public partial class E1
{
   public IQueryable<E2> NiceStack
   {
      get { return this.Stack.Select(s => s.E2).OrderBy(s => s.Position); }
   }

   public void Push(E2 e2)
   {
      this.Stack.Add(
         new E1E2
         {
            E2 = e2,
            Position = this.Stack.Max(s => s.Position) + 1
         });
   }

   public E2 Pop()
   {
      return this.Stack.
         Where(s => s.Position == this.Stack.Max(s => s.Position).
         Select(s => s.E2).
         Single();
   }
}

公共部分类E1
{
公共IQueryable堆栈
{
获取{返回this.Stack.Select（s=>s.E2）.OrderBy（s=>s.Position）；}
}
公共无效推送（E2）
{
这个是.Stack.Add(
新E1E2
{
E2=E2，
Position=this.Stack.Max（s=>s.Position）+1
});
}
公共服务
{
返回这个.Stack。
其中（s=>s.Position==this.Stack.Max（s=>s.Position）。
选择（s=>s.E2）。
单个（）；
}
}

public partial class E2
{
   public IQueryable<E1> NiceIn
   {
      get { return this.In.Select(i => i.E1); }
   }

   public IQueryable<E1> NiceTop
   {
      get
      {
         return this.In.
            Where(i => i.Position == i.E1.Stack.Max(s => s.Position)).
            Select(i => i.E1);
      }
   }
}

公共部分类E2
{
公共可查询信息
{
获取{返回this.In.Select（i=>i.E1）；}
}
公共IQueryable NiceTop
{
得到
{
把这个还给我。
其中（i=>i.Position==i.E1.Stack.Max（s=>s.Position））。
选择（i=>i.E1）；
}
}
}