Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Community
  • |
  • Diskussionsforum
Datenstruktur flexibel gestalten
Briefkasten
myCSharp.de - Member

Avatar #avatar-1523.gif


Dabei seit:
Beiträge: 444

Themenstarter:

Datenstruktur flexibel gestalten

beantworten | zitieren | melden

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: [email protected]#c#.de oder [email protected]#csharp
private Nachricht | Beiträge des Benutzers
Robin0
myCSharp.de - Member



Dabei seit:
Beiträge: 213

beantworten | zitieren | melden

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

 
Dieser Beitrag wurde 3 mal editiert, zum letzten Mal von Robin0 am .
private Nachricht | Beiträge des Benutzers
herbivore
myCSharp.de - Experte

Avatar #avatar-2627.gif


Dabei seit:
Beiträge: 52329
Herkunft: Berlin

beantworten | zitieren | melden

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
private Nachricht | Beiträge des Benutzers