Question

我同时接受C＃和VB.NET建议。

我正在使用LINQ来查询数据。我正在尝试查询父级并计算子级标记。

这是我的标签表栏：

TagId (int primary)
TagName
ParentId (int Allow NULL referred to TagId column)

以下是一些示例数据：

TagId, TagName, ParentId

1, Web Design, NULL
2, HTML, 1
3, Programming, NULL
4, CSS 3, 1

问题1 ：在我的查询结果中，我想用子标记的总和查询所有父标记。如下所示：

Web Design (2 sub tags)
Programming (0 sub tags)

问题2：如果还有子标记，则有自己的子标记

以下是一些示例数据：

TagId, TagName, ParentId

1, Web Design, NULL
2, HTML, 1
3, Programming, NULL
4, CSS 3, 1
5, HTML 4, 2
6, HTML 5, 2

所需的查询结果：

Web Design (4 sub tags)
Programming (0 sub tags)

问题2是可选的，但如果你也给出一些建议，这将是非常好的。谢谢。

Answer 1

public static IEnumerable<T> SelectDescendents<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector)
 {
  foreach(var item in source)
  {
   yield return item;
   foreach(T item2 in SelectDescendents(selector(item), selector))
    yield return item2;
  }
 }

修改用法：

Tags.where(t => t.tagID == 1).SelectDescendents(d => Tags.where(t.parentID == d.TagId)).Count();

Answer 2

好的，最简单的方法是创建一个简单的结构，如果他们有父母，你可以连接你的标签，然后遍历孩子们以产生每个标签的计数。

class Tag
{
    public Tag(int id, int? parentId, string tag)
    {
        Id = id;
        ParentId = parentId;
        TagName = tag;
    }

    public int Id { get; set; }
    public int? ParentId { get; set; }
    public string TagName { get; set; }
}

class TagNode
{
    public Tag Node { get; set; }
    public IList<TagNode> ChildNodes { get; set; }
    public int ChildNodeCount()
    {
        int count = 0;
        if (ChildNodes != null)
        {
            foreach (var node in ChildNodes)
            {
                count += node.ChildNodeCount();
            }
            count += ChildNodes.Count;
        }
        return count;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var tags = new List<Tag>();
        tags.Add(new Tag(1, null, "Web design"));
        tags.Add(new Tag(2, null, "Programming"));
        tags.Add(new Tag(3, 1, "HTML"));
        tags.Add(new Tag(4, 1, "CSS 3"));
        tags.Add(new Tag(5, 3, "HTML 4"));
        tags.Add(new Tag(6, 3, "HTML 5"));

        IList<TagNode> nodes = tags.Select(y => new TagNode { Node = y, ChildNodes = new List<TagNode>() }).ToList();
        foreach (var node in nodes)
        {
            if (node.Node.ParentId.HasValue)
                ConnectNodeToParent(nodes, node);
        }

        // print all nodes
        Console.WriteLine("=== ALL NODES ===");
        nodes.ToList().ForEach(PrintNode);

        // print root nodes
        Console.WriteLine(Environment.NewLine + "=== ROOT NODES ===");
        nodes.Where(y => y.Node.ParentId.HasValue == false).ToList().ForEach(PrintNode);

        Console.ReadLine();
    }

    private static void PrintNode(TagNode node)
    {
        Console.WriteLine("Tag id: {0}, Tag name: {1}, Tag count: {2}", node.Node.Id, node.Node.TagName, node.ChildNodeCount());
    }

    private static void ConnectNodeToParent(IList<TagNode> nodes, TagNode node)
    {
        var parentNode = nodes.Where(y => y.Node.Id == node.Node.ParentId.Value).Single();
        parentNode.ChildNodes.Add(node);
    }
}

使用上面的代码，您可以获得每个标签的信息，而不仅仅是“父”标签。

Answer 3

定义：

class Tag
{
    public int Id { get; set; }
    public string TagName { get; set; }

    public int? ParentId { get; set; }      

    public IEnumerable<Tag> Children { get; set; }
}

数据：

int id = 0;
var tags = new[]
{
    new Tag
    {
        Id = ++id,
        TagName = "Parent", 
        ChildNodes = new[]
        {
            new Tag { TagName = "Child1", Id = ++id, ParentId = 1  },
            new Tag { TagName = "Child2", Id = ++id, ParentId = 1  }
        }
    }
    new Tag
    {
        Id = ++id,
        TagName = "NoChildren"
    }
};

即

1, Parent, null
2, Child1, 1
3, Child2, 1
4, NoChildren, null

代码：

 var q = from tag in tags
         where tag.ParentId == null
         select new
         {
             Name = tag.TagName,
             ChildrenCount = tag.Children.Count()
         };

foreach (var entry in q)
{
    Console.WriteLine("{0} ({1} sub tags)", entry.Name, entry.ChildrenCount);
}

输出：

Parent (2 sub tags)
NoChildren (0 sub tags)

如果是复杂的层次结构，要递归使用所有子节点，可以使用下一个扩展方法：

public static IEnumerable<Tag> GetChildTags(this Tag tag)
{
    var children = tag.Children ?? Enumerable.Empty<Tag>();
    return children.SelectMany(c => GetChildTags(c)).Concat(children);
}

LINQ to SQL用于查询层次结构中的父级和计数子级

3 个答案: