[C# Generics] Casting auf Abgeleitete Typen?

[Elvis]

Zitat von Khabarakh:

Sieht komisch aus, funktioniert aber so

Nee, sieht noch nicht eklig genug aus.
Da fehlt jeweils die Bedingung auf den Typ selbst:

Code:

public class MyBaseList<TItem, TSelf> : List<TItem>
  where TSelf : MyBaseList<TItem, TSelf>
  where TItem : MyBaseItem<TSelf, TItem>
{

}

public class MyBaseItem<TList, TSelf>
  where TSelf : MyBaseItem<TList, TSelf>
  where TList : MyBaseList<TSelf, TList>
{
  TList list;

  public TList List
  {
    get { return list; }
    set { list = value; }
  }
}

btw: Das ist aber trotzdem alles Blödsinn.
Eine Liste ist eine Liste, ist eine Liste. Man darf die nur bis zu einem bestimmten Grad schlau machen.
So wie P's Schnipsel oben aussehen sind seine so mit Informationen vollgestopft und verknüpft, dass man sie fast gar nicht mehr benutzen kann.

Das was du da mit den Commands in der Liste machst hat da nix zu suchen. Werfe es einfach in eine eigne generische Basisklasse.
Die klinkt sich in den ListChanged event einer IBindingList ein und gut ist.
Du musst jetzt keine Listen mehr programmieren. Nur noch Ableitungen dieses Dings. Und vor allem, kannst du deine Listen auch wiederverwenden, bzw du bist nicht ständig eingeengt.

Mal ein abstrakter Bleistift der Basisklasse.

Code:

abstract class PersistenzDingens<TList, TItem> : IPersistenzDingens<TList, TItem>
  where TList : IList<TItem>, IBindingList
  where TItem : INotifyPropertyChanged
{
  readonly TList list;

  protected IList<TItem> IList
  {
    get { return (IList<TItem>)list; }
  }

  protected abstract void ItemChanged(TItem item, PropertyDescriptor propertyDescriptor);
  protected abstract void ItemAdded(TItem item);
  protected abstract void ItemRemoved(TItem item);

  public PersistenzDingens(TList list)
  {
    this.list = list;

    list.ListChanged += delegate(object sender, ListChangedEventArgs e)
    {
      TItem item = IList[e.NewIndex];
      switch (e.ListChangedType)
      {
        case ListChangedType.ItemAdded:
          ItemAdded(item);
          break;
        case ListChangedType.ItemChanged:
          ItemChanged(item, e.PropertyDescriptor);
          break;
        case ListChangedType.ItemDeleted:
          ItemRemoved(item);
          break;
        default:
          break;
      }
    };
  }
}