/// <summary>
        /// 根据结点数据计算最终条件表达式的值
        /// </summary>
        /// <param name="item">高级查询对象</param>
        /// <returns>二元组</returns>
        Tuple <string, object[]> CalcFinalExpr(AdvQueryItem item)
        {
            //检查查询项数据
            if (item == null || item.Nodes == null)
            {
                return(null);
            }
            if (!item.Nodes.Exists(t => t.ParentId == 0))
            {
                return(null);
            }

            string         whereExp   = "";
            IList <object> parameters = new List <object>();

            //查询到根节点。
            AdvQueryNode rootNode = item.Nodes.FirstOrDefault(t => t.ParentId == 0);

            //生成ODT模型的对象
            object odtObj = RefHelper.LoadClass(item.ModelName);

            ProcessQueryNode(rootNode, item, odtObj, ref whereExp, ref parameters);
            //是否有查询条件
            if (parameters.Count == 0)
            {
                return(null);
            }

            Tuple <string, object[]> result = new Tuple <string, object[]>(whereExp, parameters.ToArray());

            return(result);
        }
        /// <summary>
        /// 处理一个查询定义节点。依次递归子节点循环。
        /// </summary>
        /// <param name="node">当前节点</param>
        /// <param name="item">查询项集合</param>
        /// <param name="odtObj"></param>
        /// <param name="exp">查询表达式</param>
        /// <param name="parameters">查询表达式参数</param>
        private void ProcessQueryNode(AdvQueryNode node, AdvQueryItem item, object odtObj, ref string exp, ref IList <object> parameters)
        {
            if (node == null)
            {
                return;
            }

            //查询当前节点的子节点
            List <AdvQueryNode> children = item.Nodes.Where(t => t.ParentId == node.Id).ToList();

            if (children.Count == 0)
            {
                //没有子节点,这是一个表达式节点

                if (node.Operator.IsEmpty())
                {
                    return;
                }

                string p = "@" + parameters.Count;

                if (node.Operator.Trim().ToUpper().Equals("LIKE"))
                {
                    exp = exp + node.Expression.Trim() + ".Contains(" + p + ") ";
                }
                else if (node.Operator.Trim().ToUpper().Equals("NOT LIKE"))
                {
                    exp = exp + " !" + node.Expression.Trim() + ".Contains(" + p + ") ";
                }
                else
                {
                    exp = exp + " (" + node.Expression.Trim() + node.Operator + p + ") ";
                }

                RefHelper.SetValue(odtObj, node.Expression, node.Value);
                parameters.Add(RefHelper.GetValue(odtObj, node.Expression));

                return;
            }
            else
            {
                //有子节点,这是一个逻辑运算符节点

                exp = exp + "(";
                int i = 0;
                foreach (AdvQueryNode child in children)
                {
                    //子节点是逻辑运算符
                    if (child.Type.ToLower() == "operator")
                    {
                        if (!item.Nodes.Exists(t => t.ParentId == child.Id))
                        {
                            continue;
                        }
                    }

                    if (i > 0)
                    {
                        exp = exp + " " + node.Expression + " ";
                    }
                    //递归子节点循环。
                    ProcessQueryNode(child, item, odtObj, ref exp, ref parameters);

                    i++;
                }
                exp = exp + ")";
            }
        }