Hallo,
ich möchte meine Datenstruktur möglichst flexibel gestalten und dabei ist mir etwas untergekommen von dem ich gerne eure Meinung wüsste.
Hier ein ganz simples Beispiel (es handelt sich um eine verkette Liste wie man sieht):
public interface IData<T>
{
T Value { get; set; }
}
public interface ISNode<T>
where T : ISNode<T>
{
T Right { get; set; }
}
public interface INode<T,D> : IData<D>, ISNode<T>
where T : INode<T,D>
{
T Left { get; set; }
}
Eine verkettete Liste benötigt, je nach dem ob es eine einfache oder doppeltverkettete Liste ist, einen Zeiger auf das nächste Element. Um dies zu realisieren habe ich festgelegt, dass T vom Typ INode<T,D> sein muss. Jedoch wäre es auch genau so möglich, den Typ wie folgt zu definieren:
public interface INode<D> : IData<D>
{
INode<D> Left { get; set; }
}
Ich denke die erste generische Variante ist schöner, weil man verschiedene Typen angeben kann und der Cast Vorgang weg fällt. Bei viele generische Typen, kann es in der Handhabung schnell unübersichtlich werden. Eine Möglichkeit wäre dann den Typ fest zu legen:
public class Node<D> : INode<Node<D>, D>
{
public Node()
: base()
{
}
public Node(D Data)
{
this.Value = Data;
}
[...]
}
Nun welche Methode gefällt euch besser? Was sind eurer Meinung die Vor- und Nachteile der zwei Varianten?
Hintergrund ist der, dass auf die oben beschriebenen Datenstrukturen Algorithmen per Extensions ausgeführt werden sollen und diese sollen dann auf möglichst vielen Klassen funktionieren die die Datenstruktur implementieren.
Schaut mal im IRC vorbei:
Server: https://libera.chat/ ##chsarp
Verwende doch die
System.ComponentModel.ISite Schnittstelle
oder
public class MyHierarchicalClass<TChild, TParent>
{
List<TChild> Child {get; set;}
TParent Parent {get; set;}
}
genauer eher
public class MyHierarchicalClassBase<TChild, TParent> : Node<TChild, TParent>
where TChild : Node
{
}
public class Node<TChild, TParent> : Node<TParent>
{
List<TChild> Child {get; set;}
}
public class Node<TParent> : Node
{
TParent Parent {get; set;}
}
//edit
class Node
{
}
Hallo Briefkasten,
also für mich - so wie die Anforderung verstanden habe - ein klarer Fall für:
public interface IData<T>
{
T Value { get; set; }
}
public interface ISNode<T> : IData<T>
{
ISNode<T> Right { get; set; }
}
public interface INode<T> : ISNode<T>
{
INode<T> Left { get; set; }
}
In meinen Augen "vergewaltigst" du mit deinem Ansatz das Konzept der Constrains.
herbivore