Wie ein Gewindekommentarsystem in C # bauen? Hilfe

Question

Im Aufbau ein Threaded Kommentar-Systems für eine Website von mir und ich lief in ein Problem ...

Ich habe eine Liste aus einer Datenbank abgerufen, die ein ID-Feld und ein übergeordnetes ID-Feld hat. Das übergeordnete ID-Feld kann null sein, aber das ID-Feld wird nie Null sein.

Da dies ein Gewindekommentarsystem sein, organisiere ich die Liste, wo die ID ist die obere, aber wenn ein Elternteil ID vorhanden ist, dann wäre es unter der Kennung eingefügt werden. Dann kann dies auch für die Unendlichkeit weitergehen. So ist die zweite Ebene hat nun auch eine ID und und ich möchte ein Element einzufügen, mit einem Elternteil ID dieser ID darunter.

Zum Beispiel:

--- 1. Blah

-------- 2. Blabla -> ParentID = 1

----------- 3. Blabla -> parentID = 2

-------------- 4. Blabla -> parentID = 3

----------- 3.Blah Blah -> parentID = 2

-------- 2. Blabla -> parentID = 1

Ich glaube, Sie erhalten den Punkt.

So, hier ist das, was ich bisher ...

List<comment> finalList = new List<comment>();
    for (int i = 0; i < getComments.Count(); i++)
    {
        string item = getComments[i].parentComment;
        getComments[i].threadID = 1;
        finalList.Add(getComments[i]);
        for (int ii = 0; ii < getComments.Count(); ii++)
        {
            if (getComments[ii].commentID == item)
            {
                getComments[ii].threadID = 2;
                finalList.Add(getComments[i]);
            }
        }
    }

Es scheint, es auf halben Weg zu sortieren, aber nicht wirklich ... Die ThreadID natürlich ist, wie weit es nach rechts gepflanzt wird.

Answer 1

Danke allen für Ihre Hilfe Jungs. Ich kann es tun zu schätzen wissen.

ich aber habe, finde etwas von einem Mann, der absolut alles für sie geschrieben hat.

http://www.scip.be/index.php?Page=ArticlesNET23

http://www.scip.be/index.php?Page=ArticlesNET09

http://www.scip.be/index.php?Page=ArticlesNET18

Answer 2

Da Sie die Count () Erweiterungsmethode statt der Count-Eigenschaft verwenden (was eine leichte Ineffizienz in sich selbst ist, mit foreach wäre besser, mit allerdings starten). Sie vermutlich .NET 3.5 mit

Ich glaube nicht, dass ich Ihr Programm vollständig verstehen - zum Beispiel, was es zu sagen, dass der Kommentar mit threadID = 4 im Diagramm unter dem ersten threadID = 3 Element anstelle der zweiten

geht?

Ohne viel zu wissen, in der Art und Weise der Details, was Sie nach in der Regel würde ich eine Kommentierung Datenstruktur prüfen mit:

• CommentID: die ID dieser Entität
• RootID: die ID des Stammelement für den Faden (so dass alle Kommentare für einen Thread holen kann leicht)
• ParentID: die CommentID des Mutter für diesen Kommentar, oder null, wenn es das Wurzelelement ist
• Zeitstempel:. Oder etwas anderes, das dem Kind, innerhalb einer übergeordneten erlauben würde, in geeigneter Weise sortiert werden

Da wäre es ziemlich einfach, die Einrückungsebene zu arbeiten, wenn das, was Sie besorgt sind. Wenn das nützlich klingt, kann ich mehr ins Detail gehen -. Wenn nicht, bitte die Frage klären

Answer 3

Sie müssen eine rekursive Funktion, und auf der Grundlage, wie es aussieht, wie Sie die Liste sind durchqueren, wäre es wahrscheinlich besser seine ID zu speichern und ChildID (statt Mutter ID). Auf diese Weise die rekursive Funktion eine Traversal, wenn ChildID == null enden kann.

Answer 4

Dies könnte funktionieren:

class Program
    {
        static void Main(string[] args)
        {
            CommentCollection collection=new CommentCollection();
            Comment c1=new Comment("Blah",1,0,collection);
            Comment c2=new Comment("Blah blah",2,1,collection);
            Comment c3=new Comment("Blah blah", 3, 2, collection);
            Console.WriteLine(collection);
        }
    }
    [DebuggerDisplay("{id}-{parentId}: {text}")]
    class Comment:IEnumerable<Comment>
    {
        private readonly CommentCollection collection;
        private readonly int parentId;

        public Comment(string text, int id, int parentId, CommentCollection collection)
        {
            Id = id;
            this.parentId = parentId;
            collection.Add(this);
            this.collection = collection;
            this.text = text;
        }
        public Comment Parent
        {
            get
            {
                if (parent == null)
                {
                    parent = parentId == 0 ? null : collection[parentId];
                }
                return parent;
            }
        }

        private Comment parent;
        private readonly string text;
        public int Id{ get; private set;}
        public IEnumerator<Comment> GetEnumerator()
        {
            return collection.Where(c => c.Parent == this).GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        public int Level
        {
            get { return Parent == null ? 0 : Parent.Level + 1; }
        }
        public override string ToString()
        {
            return Parent == null ? text : Parent + " > " + text;
        }
        public string ToString(bool tree)
        {
            if (!tree)
            {
                return ToString();
            }
            else
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine(new string(' ', Level) + ToString(false));
                foreach (Comment comment in this)
                {
                    output.AppendLine(comment.ToString(true));
                }
                return output.ToString();
            }
        }
    }
    class CommentCollection:IEnumerable<Comment>
    {
        public void Add(Comment comment)
        {
            comments.Add(comment.Id,comment);
        }
        public Comment this[int id]
        {
            get { return comments[id]; }
        }
        private readonly Dictionary<int,Comment> comments=new Dictionary<int, Comment>();

        public IEnumerator<Comment> GetEnumerator()
        {
            return comments.Select(p => p.Value).GetEnumerator();
        }

        public IEnumerable<Comment> GetTopLevel()
        {
            return comments.Where(c => c.Value.Parent == null).
                Select(c => c.Value);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        public override string ToString()
        {
            StringBuilder output=new StringBuilder();
            foreach (Comment comment in GetTopLevel())
            {
                output.AppendLine(comment.ToString(true));
            }
            return output.ToString();
        }
    }