C# 泛型限制为一组模型(没有相关的基类)

Question

不知道谷歌该怎么做才能解决这个问题，但我希望有一种方法可以简化这一点。我正在使用一组不扩展基类（级别 1、级别 2 等）的实体。 级别 1 是根，级别 2 是第二层，并引用级别 1，依此类推。我已经粗略简化了下面的示例，但有很多"重复"的模板化代码，并且正在寻找一种简化它的方法。

我

有一组类似"组织"的实体，我所关心的只是ID、Name和Parent。 我有一个包装它们的OrgBO类，每个实体类型都有一个BuildFrom方法。

//OrgBO class
public void BuildFrom(Level1 entity){
    this.ID = entity.Level1ID;
    this.Type = OrgTypes.Level1;
    this.Name = entity.Name;
    this.Parent = null;
}
public void BuildFrom(Level2 entity){
    this.ID = entity.Level2ID;
    this.Type = OrgTypes.Level2;
    this.Name = entity.Name;
    this.Parent = new OrgBO(entity.Level1);
}

我已经为每个类型创建了一个构造函数：

public OrgBO(Client entity){
    BuildFrom(entity);
}
public OrgBO(Region entity) {
    BuildFrom(entity);
}

但我在重复自己，我是否错过了抽象这一点的generic方法？ 以某种方式有一个构造函数调用BuildFrom<T>并以某种方式将其约束为类类型列表？

//not sure how to limit to my types..
public OrgBO<T>(T entity) {
    BuildFrom<T>(entity);
}

---

希望这不是清晨的脑子放屁。 额外的信息（以防窥视护理）。

 public enum OrgTypes { 
    Level1 = 1, 
    Level2 = 2, 
    Level3 = 3, 
    Level4 = 4 
};

Answer 1

如果不想

让关卡类继承自公共基类，请让它们继承自公共接口

public interface IEntity
{
    int ID { get; set; }
    OrgTypes Type { get; } // Only getter, classes must know their own type.
    string Name { get; set; }
    IEntity Parent { get; set; }
}

现在，您可以像这样声明 Org 类型：

public class OrgBO<TEntity, TParent> : IEntity
    where TEntity : IEntity // Generic type constraints
    where TParent : IEntity
{
    private TEntity _entity;
    public OrgBO(TEntity entity)
    {
        _entity = entity;
        if (entity.Type == OrgTypes.Level1) {
            this.ParentBO = null;
        } else {
            this.ParentBO = new OrgBO<TParent>(entity.Parent);
        }
    }
    public int ID { get { return _entity.ID; } set{ _entity.ID = value; } }
    public OrgTypes Type { get { return _entity.Type; } }
    public string Name { get { return _entity.Name; } set{ _entity.Name = value; } }
    // Implement explicitly in order to hide it if not accesses through interface.
    IEntity IEntity.Parent {
        get { return _entity.Parent; }
        set{ _entity.Parent = value; }
    }
    public OrgBO<TParent> ParentBO { get; private set; }
}

关卡类可能如下所示：

public class Level2 : IEntity
{
    public int ID { get; set; }
    public OrgTypes Type { get { return OrgTypes.Level2; } }
    public string Name { get; set; }
    public IEntity Parent { get; set; }
    public Level1 Level1Parent {
        get { return (Level1)Parent; }
        set { Parent = value; }
    }
}

对 Level1 对象（如 new OrgBO<Level1, object>(level1Object) ）使用虚拟TParent。当然，您也可以将实体值复制到 OrgBO 对象中，而不是包装实体对象，如果它更符合您的需求。

此外，OrgBO不一定需要实现IEntity，但由于相似性，这是有意义的。如果没有，则可以删除 OrgBO 中的 Parent 属性。

Answer 2

这是我如何完成它... 感谢@IC。

public OrgBO(IOrgBase entity){
        PopulateFrom(entity);
}
public void PopulateFrom(IOrgBase entity){
        this.ID = entity.GetID();
        this.Type =  entity.GetEntityType();
        this.Name = entity.GetName();
        if (entity.GetParent() !=null)
        {
            this.Parent = new OrgBO(entity.GetParent());
        }
    }

--- 实体框架扩展类...

namespace Unboxed.Models
{
  public interface IOrgBase{
    string GetName();
    int GetID();
    IOrgBase GetParent();
    string GetEntityType();
   }   
  [MetadataType(typeof(Level1_Meta))]
  public partial class Level1 : IOrgBase{
      #region IOrgBase impl
      public string GetName()
      {
        return Level1Name;
      }
      ....
      #endregion IOrgBase impl
      ...
     }
}