Solución a la falta de covarianza con los genéricos en c # 2.0 (BindingList)

Question

Es una cuestión de diseño. Tengo un objeto de negocio, y 5 tipos de objetos de negocio que se derivan de ella.

También a tener una clase que tiene BindingList como miembro. Voy a tener 5 clases derivadas de ella.

Desde covarianza no funciona aquí, ¿cómo estructurar el diseño para minimizar el código de repetición? Podría, por supuesto, tirar la BindingList e ir con DataTable en cuyo caso se elimina el problema.

Pero como todos alabanzas sobre BindingList Me encanta ver como ustedes se acercaría a esto.

SOLUCIÓN (basado en la respuesta 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

Asumiendo que su miembro de BindingList es privada (o protegido), y no se expone lo contrario en su API de la clase, que probablemente querrá algo como esto:

  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

Este ejemplo sólo funciona con .NET 3.5 o superior. : (

Tal vez una propiedad que devuelve todos los objetos heredados. Yo tenía una pregunta similar y utilizando System.Linq. Esto es lo que solía:

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

O fundido todos ellos al padre:

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

El código anterior era de esta respuesta . Gracias Matt.

Answer 3

Si usted tiene una relación de herencia entre los hijos, por qué no usar BindingList<TheBaseClass> como su tipo de colección principal?

El ejemplo más destacado de cuando tendría que usar covarianza es cuando se quería tratar una BindingList<TheDerivedClass> como BindingList<TheBaseClass>. ¿Puede darnos un ejemplo concreto de que esto le está tropezar? Muchos de los escenarios para los que coviarance es un anaswer también se pueden resolver con una combinación de medicamentos genéricos, las limitaciones y las interfaces en ocasiones adicionales.