Question

我有一个复杂的对象正在使用许多嵌套级别，每个级别反过来可以有嵌套。

将它放在图表中，

有数据结构＆＃34;条件＆＃34;在其下可以有条件或逻辑运算符。

每个逻辑运算符都可以包含任何逻辑或条件运算符。

我的问题是，我必须遍历这个嵌套的条件对象和修改这个系统内部的嵌套条件对象，并将其转换为另一个类似形式的DS，我们以WS的形式向外部公开。

另一个DS与条件对象具有类似形式，具有条件和逻辑运算符。我必须为映射到新对象做很多类型转换和字符串转换。但那很好。

这里唯一的问题是我发现很难遍历关卡并将每个叶子节点与其父节点相关联。我尝试了递归，但我失去了上下文。例如，如果我遍历OR条件，我将失去AND的跟踪，这是它的父级，而父级又有2个等于条件。

我需要一种方法来遍历这个树状结构并将其存储在一个对象中，然后将该对象转换为另一种类似的形式。

这是我到目前为止所尝试的。

if (constraint.Condition != null)
                    {
                        EvaluateCondition(constraint.Condition);
                        OxpdConditions[] _nestedConditionsMapToArray = new OxpdConditions[_nestedConditionsMap.Count];
                        _nestedConditionsMapToArray = _nestedConditionsMap.ToArray();

                        if (_nestedConditionsMapToArray[0].Condition == "AND")
                        {

                            int conditionDepth = _nestedConditionsMapToArray[0].NestedConditionCount;
                            And and = new And();

                            for (int i = 0; i < conditionDepth; i++)
                            {
                                switch (_nestedConditionsMapToArray[i + 1].Condition)
                                {
                                    case "EQUAL":
                                        Equals andEqual = new Equals();
                                        andEqual.optionName = constraint.Condition.NestedConditions[i].PropertyName;
                                        andEqual.optionValue = constraint.Condition.NestedConditions[i].PropertyValue.ToString();
                                        break;
                                    case "OR":
                                        Or andOr = new Or();

                                    default:
                                        break;
                                }
                            }
                        }

                    }




                     private void EvaluateCondition(ICondition condition)
        {
            if (condition != null)
            {
                if (condition.NestedConditions != null)
                {
                    OxpdConditions rootItem = new OxpdConditions();
                    rootItem.Condition = condition.ConditionType.ToString();
                    rootItem.NestedConditionCount = condition.NestedConditions.Count;
                    _nestedConditionsMap.Add(rootItem);

                    foreach (var con in condition.NestedConditions)
                    {
                        if (con.ConditionType == ConditionType.EQUAL)
                        {
                            OxpdConditions nestedItem = new OxpdConditions();
                            nestedItem.Condition = con.ConditionType.ToString();
                            nestedItem.NestedConditionCount = 0;
                            _nestedConditionsMap.Add(nestedItem);
                        }
                        else
                        {
                            //_nestedConditionsMap.Add(con.ConditionType.ToString(), condition.NestedConditions.Count);
                            EvaluateCondition(con);
                        }
                    }
                }
                else
                {
                    OxpdConditions nonNestedItem = new OxpdConditions();
                    nonNestedItem.Condition = condition.ConditionType.ToString();
                    nonNestedItem.NestedConditionCount = 0;
                    _nestedConditionsMap.Add(nonNestedItem);
                }

            }
        }

public class OxpdConditions
        {
            public string Condition { get; set; }
            public int NestedConditionCount { get; set; }
        }

private Dictionary<string, int> _nestedConditionsMap = new Dictionary<string, int>();

我将条件对象传递给EvaluateCondition（）方法，该方法轮流遍历整个树并在字典对象中添加条件和深度。字典对象看起来像，

{而且，3}，{或者，2}，（当量，0}，{当量，0}，（当量，0}，{当量，0}

我正在尝试从此字典对象中提取数据并尝试映射到另一个对象。这就是我被困住的地方。

需要注意的一点是，嵌套级别是动态的，并且每种条件都有所不同。在OR条件下，也可以有另一个OR条件。

有没有动态的方法可以在C＃中处理这类问题。我尝试过使用LINQ，但坦率地说，我无法取得任何突破。

任何指针都非常有用。感谢

解析嵌套数据结构（对象）并将其映射到另一个数据结构对象c＃

0 个答案: