1

这是一个设计问题。我有一个业务对象，以及从它派生的 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>();
        }


    }
4

3 回答 3

3

Assuming your BindingList member is private (or protected), and isn't otherwise exposed in your class API, you'd probably want something like this:

  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> { ... }
  ...
于 2009-07-25T00:12:57.823 回答
1

This example only works with .net 3.5 or higher. :(

Perhaps a property that returns all of the inherited objects. I had a similar question and using System.Linq. Here is what I used:

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

Or cast all of them to the parent:

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

The above code was from this answer. Thanks Matt.

于 2009-07-25T00:25:37.530 回答
0

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

The most prominent example of when you would need to use covariance is when you wanted to treat a BindingList<TheDerivedClass> as BindingList<TheBaseClass>. Can you give us a specific example of where this is tripping you up? Many of the scenarios for which coviarance is an anaswer can also be solved with a combination of generics, constraints and occasionally additional interfaces.

于 2009-07-25T00:09:57.030 回答