Come creare un sistema di commenti thread in C #? Aiuto

Question

Sto costruendo un sistema di commenti threaded per un mio sito Web e ho riscontrato un problema ...

Ho un elenco ESTRATTO DA UN DATABASE che ha un campo ID e un campo ID padre. Il campo ID padre può essere nullo, ma il campo ID NON sarà MAI nullo.

Poiché si tratterà di un sistema di commenti con thread, organizzo l'elenco in cui l'ID è quello principale, ma se esiste un ID principale, verrà inserito sotto l'ID. Quindi questo può continuare anche per l'infinito. Quindi il secondo livello ora ha anche un ID e voglio inserire qualsiasi articolo con un ID genitore di quell'ID sotto di esso.

Ad esempio:

--- 1. Blah

-------- 2. Blah Blah - > ParentID = 1

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

-------------- 4. Blah Blah - > parentID = 3

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

-------- 2. Blah Blah - > parentID = 1

Penso che tu capisca il punto.

Quindi ecco quello che ho finora ...

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]);
            }
        }
    }

Sembra ordinarlo a metà strada, ma non proprio ... Il ThreadID è ovviamente quanto lontano viene piantato a destra.

Answer 1

Grazie a tutti per il vostro aiuto ragazzi. Lo apprezzo.

Tuttavia, ho trovato qualcosa di un ragazzo che ha scritto assolutamente tutto per questo.

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

Dato che stai usando il metodo di estensione Count () invece della proprietà Count (che è una leggera inefficienza in sé; usando foreach sarebbe meglio iniziare però) presumibilmente stai usando .NET 3.5.

Non credo di comprendere appieno il tuo schema - ad esempio, cosa c'è da dire che il commento con threadID = 4 nel tuo diagramma va sotto il primo elemento threadID = 3 anziché il secondo?

Senza conoscere molto i dettagli di ciò che stai cercando, in generale prenderei in considerazione una struttura di dati per i commenti con:

• CommentID: l'ID di questa entità
• RootID: l'ID dell'elemento root per il thread (in modo da poter recuperare facilmente tutti i commenti per un thread)
• ParentID: il CommentID del parent per questo commento, oppure null se è l'elemento root
• Timestamp: o qualcos'altro che consentirebbe di ordinare in modo appropriato i commenti dei bambini all'interno di un genitore.

Detto questo, sarebbe abbastanza facile capire il livello di rientro, se è questo che ti preoccupa. Se questo sembra utile, posso entrare in maggiori dettagli - in caso contrario, chiarire la domanda.

Answer 3

È necessaria una funzione ricorsiva e, in base al modo in cui sembra che si stia attraversando l'elenco, probabilmente sarebbe meglio archiviare ID e ChildID (anziché l'ID principale). In questo modo la funzione ricorsiva può terminare un attraversamento quando ChildID == null.

Answer 4

Potrebbe funzionare:

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();
        }
    }