Question

这是一个设计问题。我有一个业务对象，以及从中派生的5个业务对象类型。

我还将有一个将BindingList作为成员的类。我将从中派生出5个类。

由于协方差在这里不起作用，您如何构建设计以最小化代码重复？我当然可以查看BindingList并使用DataTable，在这种情况下可以消除问题。

但是既然每个人都对BindingList赞不绝口，我很乐意看看你们会如何处理这个问题。

解决方案（基于Pavel Minaev的回答）：

public class SampleBase
    {
        protected string m_seq;
        protected string m_id;
        protected string m_weight;
        protected string m_units;       

        public SampleBase(string seq, string id, string weight, string units)
        {
            Seq = seq;
            Id = id;
            Weight = weight;
            Units = units;
        }

        public SampleBase() { }

        public string Seq
        {
            get { return m_seq; }
            set { m_seq = value; }
        }

        public string Id
        {
            get { return m_id; }
            set { m_id = value; }
        }

        public string Weight
        {
            get { return m_weight; }
            set { m_weight = value; }
        }

        public string Units
        {
            get { return m_units; }
            set { m_units = value; }
        }

    }

    public class FwdSample : SampleBase
    {
        protected string m_std_id;

        public FwdSample() { }

        public FwdSample (string seq, string id, string weight, string units, string std_id ) : base(seq, id, weight, units)
        {
            StdId = std_id;
        }

        public string StdId 
        {
            get { return m_std_id; }
            set { m_std_id = value; }
        }
    }
    //End of Sample Classes





    public abstract class RunBase<T> where T : SampleBase , new()
    {
        protected BindingList<T> m_samples;



        public RunBase() {}

        public void Add(T sample)
        {
            m_samples.Add(sample);
        }

        public void Update(int index, T sample)
        {
            m_samples[index] = sample;
        }

        public void Delete(int index)
        {
            m_samples.RemoveAt(index);
        }



        public BindingList<T> Samples
        {
            get { return m_samples; }
        }
    }


    public class FwdRun : RunBase<FwdSample>
    {

        public FwdRun()
        {
            m_samples = new BindingList<FwdSample>();
        }


    }

Answer 1

假设您的BindingList成员是私有的（或受保护的），并且未在您的类API中公开，您可能需要以下内容：

  class Base
  {
      // No BindingList here. All members that don't need it should be here
      ...
  }

  class Base<TDerived> : Base where TDerived : Base<TDerived>
  {
       BindingList<TDerived> list = new BindingList<TDerived>();

       // All members that need BindingList should be here
  }

  class Derived1 : Base<Derived1> { ... }
  class Derived2 : Base<Derived2> { ... }
  ...

Answer 2

此示例仅适用于.net 3.5或更高版本。：（

可能是返回所有继承对象的属性。我有一个类似的问题，并使用System.Linq。这是我使用的：

List<A> testme = new List<B>().OfType<A>().ToList();

或者将所有这些都投射到父母身上：

List<A> testme = new List<B>().Cast<A>().ToList();

以上代码来自this answer。谢谢马特。

Answer 3

如果孩子之间有继承关系，为什么不使用BindingList<TheBaseClass>作为主要的收集类型？

当您需要使用协方差时，最突出的例子是您希望将BindingList<TheDerivedClass>视为BindingList<TheBaseClass>。你能给我们一个具体的例子说明这会让你绊倒吗？ coragerance是anaswer的许多场景也可以通过泛型，约束和偶尔附加接口的组合来解决。

解决c＃2.0中缺少与泛型的协方差（BindingList）

3 个答案: