Solution au manque de covariance avec les génériques en C # 2.0 (BindingList)

Question

Il est une question de conception. J'ai un objet métier, et 5 types d'objets d'affaires qui en sont dérivés.

Je vais aussi avoir une classe qui a BindingList en tant que membre. Je vais avoir 5 classes dérivées.

Depuis covariance ne fonctionne pas ici, comment voulez-vous structurer la conception afin de minimiser la répétition de code? Je pourrais bien sûr le mandrin BindingList et aller avec DataTable dans ce cas, le problème est éliminé.

Mais puisque tout le monde parle BindingList j'aimerais voir comment les gars se rapprocherait cela.

SOLUTION (basée sur la réponse de 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

En supposant un membre de votre BindingList est privé (ou protégé), et n'est pas autrement exposé dans votre API de classe, vous voudrez probablement quelque chose comme ceci:

  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

Cet exemple fonctionne uniquement avec .net 3.5 ou supérieur. : (

Peut-être une propriété qui retourne tous les objets hérités. J'avais une question similaire et en utilisant System.Linq. Voici ce que je:

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

Ou jeter tous à la société mère:

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

Le code ci-dessus était de cette réponse . Merci Matt.

Answer 3

Si vous avez une relation d'héritage entre les enfants, pourquoi ne pas utiliser BindingList<TheBaseClass> comme principal type de collection?

L'exemple le plus important quand vous devez utiliser covariance est quand vous voulez traiter un BindingList<TheDerivedClass> comme BindingList<TheBaseClass>. Pouvez-vous nous donner un exemple précis où cela vous trébucher? La plupart des scénarios pour lesquels coviarance est un anaswer peut également être résolu avec une combinaison de médicaments génériques, les contraintes et les interfaces de temps en temps supplémentaires.