Question

我有一个字典，其中一个View Order作为键，值是一个包含数据的对象。查看顺序，类型，testName，testGUSelected。数据看起来像是字典

10, [10, A, English1, No];
12, [12, B, English1, Yes];
14, [14, C, English1, No];
16, [16, C, English1, No];
20, [20, B, English1, No];
22, [22, C, English1, No];
24 [24, C English1, No];
40 [40, A, English1, No];
42, [42, B, English1, No];
45,  [45, C, English1, Yes];

我需要计算'C'属于它的父亲'B'的数量，还要计算'B'属于他们的父'A'的数量。确定哪个C属于特定'B'的方法是C来自B并且他们的视图顺序大于父'B'并且子列表继续直到你击中字典中的下一个B. 确定哪个B属于特定'A'的方式是B'在'A'之后并且他们的视图顺序大于父'A'并且子列表继续直到你在字典中击中下一个A.

我需要计算'C'属于它的父母'B'的数量，并检查所有属于父'B'的C是否标记为'是'然后更新父'B'的值从'不'到'是'。对于子'B'和父'A'，需要进行相同类型的计算和更新。

非常感谢任何帮助/建议。提前感谢您的帮助。

Answer 1

这里有很多需要改进的地方，但您要做的是将数据排序并进入树状结构。然后循环遍历子节点以查看它们的值是否设置为Yes，并调整当前节点。

class Program
{
    static void Main(string[] args)
    {
        //Load your data
        Dictionary<int, Data> data = new Dictionary<int, Data>(10);
        data.Add(10, new Data(10, Data.ViewType.A, "English1", Data.Selected.No));
        data.Add(12, new Data(12, Data.ViewType.B, "English1", Data.Selected.Yes));
        data.Add(14, new Data(14, Data.ViewType.C, "English1", Data.Selected.No));
        data.Add(16, new Data(16, Data.ViewType.C, "English1", Data.Selected.No));
        data.Add(20, new Data(20, Data.ViewType.B, "English1", Data.Selected.No));
        data.Add(22, new Data(22, Data.ViewType.C, "English1", Data.Selected.No));
        data.Add(24, new Data(24, Data.ViewType.C, "English1", Data.Selected.No));
        data.Add(40, new Data(40, Data.ViewType.A, "English1", Data.Selected.No));
        data.Add(42, new Data(42, Data.ViewType.B, "English1", Data.Selected.No));
        data.Add(45, new Data(45, Data.ViewType.C, "English1", Data.Selected.Yes));

        List<int> sortedViewOrder = data.Keys.ToList<int>();
        sortedViewOrder.Sort();
        Tree dataTree = new Tree(new TreeNode(new Data(0, Data.ViewType.A, "English1", Data.Selected.No)));
        //Assuming all your data is correctly ordered and A always has at least one B below it, B always has at least one C below it.
        for (int i = 0; i < sortedViewOrder.Count; )
        {
            TreeNode subTreeA = new TreeNode(data[sortedViewOrder[i]]);
            i++;
            while (i < data.Count && data[sortedViewOrder[i]].Type == Data.ViewType.B)
            {
                TreeNode subTreeB = new TreeNode(data[sortedViewOrder[i]]);
                i++;
                while (i < data.Count && data[sortedViewOrder[i]].Type == Data.ViewType.C)
                {
                    subTreeB.AddChild(new TreeNode(data[sortedViewOrder[i]]));
                    i++;
                }
                subTreeA.AddChild(subTreeB);
            }
            dataTree.Root.AddChild(subTreeA);
        }
        foreach (TreeNode childA in dataTree.Root.Children)
        {
            foreach (TreeNode childB in childA.Children)
            {
                if (childB.AllChildrenTestGUSelectedYes())
                {
                    childB.Data.TestGUSelected = Data.Selected.Yes;
                }
            }
            if (childA.AllChildrenTestGUSelectedYes())
            {
                childA.Data.TestGUSelected = Data.Selected.Yes;
            }
        }
        foreach (TreeNode childA in dataTree.Root.Children)
        {
            Console.WriteLine(childA.Data.ToString());
            foreach (TreeNode childB in childA.Children)
            {
                Console.WriteLine(childB.Data.ToString());
                foreach (TreeNode childC in childB.Children)
                {
                    Console.WriteLine(childC.Data.ToString());
                }
            }
        }
        Console.ReadLine();
    }

    public class Tree
    {
        public TreeNode Root { get; private set; }
        public Tree(TreeNode root)
        {
            Root = root;
        }
    }

    public class TreeNode
    {
        public Data Data { get; private set; }
        public List<TreeNode> Children { get; private set; }
        public TreeNode(Data data)
        {
            Data = data;
            Children = new List<TreeNode>();
        }
        public void AddChild(TreeNode child)
        {
            Children.Add(child);
        }
        public bool AllChildrenTestGUSelectedYes()
        {
            if (Children.Count == 0)
            {
                return Data.TestGUSelected == Data.Selected.Yes;
            }
            bool allChildrenYes = true;
            foreach (TreeNode child in Children)
            {
                if (!child.AllChildrenTestGUSelectedYes())
                {
                    allChildrenYes = false;
                    break;
                }
            }
            return allChildrenYes;
        }
    }

    public class Data
    {
        public int ViewOrder { get; set; }
        public ViewType Type { get; set; }
        public string TestName { get; set; }
        public Selected TestGUSelected { get; set; }
        public Data(int viewOrder, ViewType type, string testName, Selected testGUSelected)
        {
            ViewOrder = viewOrder;
            Type = type;
            TestName = testName;
            TestGUSelected = testGUSelected;
        }
        public override string ToString()
        {
            return "viewOrder:" + ViewOrder + " type:" + Type + " testName:" + TestName + " testGUSelected:" + TestGUSelected;
        }

        public enum ViewType
        {
            A, B, C
        }

        public enum Selected
        {
            Yes, No
        }
    }
}

Sub Totals和Total使用linq表示字典中包含的数据

1 个答案: