Laden...

Datenstruktur flexibel gestalten

Erstellt von Briefkasten vor 10 Jahren Letzter Beitrag vor 10 Jahren 1.424 Views
Briefkasten Themenstarter:in
446 Beiträge seit 2004
vor 10 Jahren
Datenstruktur flexibel gestalten

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

R
212 Beiträge seit 2012
vor 10 Jahren

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
{
}

 
49.485 Beiträge seit 2005
vor 10 Jahren

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