¿Cómo construir un sistema de comentarios roscado en C #? Ayuda

Question

Estoy construyendo un sistema de comentarios con hilos para un sitio web mío y me encontré con un problema ...

Tengo una lista EXTRAIDA DE UNA BASE DE DATOS que tiene un campo ID y un campo ID principal. El campo de ID principal puede ser nulo, pero el campo de ID NUNCA será nulo.

Dado que este será un sistema de comentarios enhebrado, organizo la lista donde la ID es la principal, pero si existe una ID principal, se insertará debajo de la ID. Entonces esto puede continuar también hasta el infinito. Entonces, el segundo nivel ahora también tiene una ID y quiero insertar cualquier elemento con una ID principal de esa ID debajo.

Por ejemplo:

--- 1. Blah

-------- 2. Bla, bla, y gt; ParentID = 1

----------- 3. Bla, bla, y gt; parentID = 2

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

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

-------- 2. Bla, bla, y gt; parentID = 1

Creo que entiendes el punto.

Entonces, esto es lo que tengo hasta ahora ...

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

Parece ordenarlo a la mitad, pero no realmente ... El ThreadID es, por supuesto, lo lejos que se planta a la derecha.

Answer 1

Gracias a todos por su ayuda chicos. Lo aprecio.

Sin embargo, encontré algo de un tipo que escribió absolutamente todo para ello.

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

Dado que está utilizando el método de extensión Count () en lugar de la propiedad Count (que es una ligera ineficiencia en sí misma; usar foreach sería mejor para empezar), presumiblemente está utilizando .NET 3.5.

No creo que entienda completamente su esquema; por ejemplo, ¿qué hay para decir que el comentario con threadID = 4 en su diagrama va debajo del primer elemento threadID = 3 en lugar del segundo?

Sin saber mucho en cuanto a los detalles de lo que busca, en general consideraría una estructura de datos de comentarios con:

• CommentID: el ID de esta entidad
• RootID: el ID del elemento raíz del hilo (para que pueda buscar todos los comentarios de un hilo fácilmente)
• ParentID: el CommentID del padre para este comentario, o nulo si es el elemento raíz
• Marca de tiempo: O algo más que permitiría que los comentarios secundarios dentro de uno de los padres se clasifiquen adecuadamente.

Dado eso, sería bastante fácil calcular el nivel de sangría, si eso es lo que le preocupa. Si eso suena útil, puedo entrar en más detalles; de lo contrario, aclare la pregunta.

Answer 3

Necesita una función recursiva y, según cómo parezca que está atravesando la lista, probablemente sería mejor almacenar la ID y la ID del niño (en lugar de la ID de los padres). De esta forma, la función recursiva puede finalizar un recorrido cuando ChildID == null.

Answer 4

Esto podría funcionar:

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