C# 用于序列化逻辑表达式的结构

我需要将逻辑表达式列表传递给WCF服务，如下所示：

[0] (A & B) || (C & D)
[1] (E || F)
[2] G

上面是三个元素的示例列表，每个元素描述一个包含AND、OR和分组的布尔表达式。条件（A、B、C、D、E、F、G）中的项目均为相同类型的实体

是只使用字符串并在收到消息时在服务器上解析它们的最佳方法，还是我可以使用类结构/层次结构？我很难思考如何将分组和布尔条件建模为类结构

现实世界的目标是为批准或拒绝已发布文档的用户的多级列表建模。当满足列表中第一个元素表示的条件时，将通知下一级别的用户需要他们的输入。这将一直持续到所有条件都已计算完毕。

两个选项（使用字符串和数据结构）都可以正常工作-这将取决于您需要将表达式转换为字符串以通过线路传输（这可能导致较小的消息大小）或直接传输数据结构的位置（连接大小可能更大，但您将在客户端和服务器之间共享同一个表达式树）

下面的代码为您的示例显示了一种可能的数据结构-树（它当前是二进制的，但不一定是）

公共类堆栈溢出\u 6915554
{
[数据合同]
[KnownType（typeof（LeafExpression））]
[KnownType（typeof（BinaryExpression））]
公共类表达式
{
}
[数据合同]
公共类表达式：表达式
{
[数据成员]
公共字符串名称；
}
[数据合同]
公共类二进制表达式：表达式
{
[数据成员]
公共二进制运算符；
[数据成员]
公众表达左；
[数据成员]
公众表达权；
}
公共枚举二进制运算符
{
以及，
或
}
公共静态无效测试（）
{
列表表达式=新列表（）；
添加（新的二进制表达式）
{
左=新的二进制表达式
{
左=新的叶表达式{Name=“A”}，
运算符=二进制运算符。和，
右=新的叶表达式{Name=“B”}，
},
运算符=二进制运算符。或，
右=新的二进制表达式
{
左=新的叶表达式{Name=“C”}，
运算符=二进制运算符。和，
Right=新的leaf表达式{Name=“D”}，
}
});
添加（新的二进制表达式）
{
左=新的叶表达式{Name=“E”}，
运算符=二进制运算符。或，
右=新的叶表达式{Name=“F”}
});
Add（新的LeafExpression{Name=“G”}）；
XmlWriterSettings ws=新的XmlWriterSettings
{
缩进=真，
缩进字符=”，
编码=新的UTF8编码（错误），
OmitXmlDeclaration=true，
};
MemoryStream ms=新的MemoryStream（）；
XmlWriter w=XmlWriter.Create（ms，ws）；
DataContractSerializer dcs=新的DataContractSerializer（类型（列表））；
dcs.WriteObject（w，表达式）；
w、 冲洗（）；
Console.WriteLine（Encoding.UTF8.GetString（ms.ToArray（））；
}
}

两个选项（使用字符串和数据结构）都可以正常工作-这取决于您需要将表达式转换为字符串以通过线路传输（这可能会导致较小的消息大小）或直接传输数据结构的位置（连接大小可能更大，但您将在客户端和服务器之间共享同一个表达式树）

下面的代码为您的示例显示了一种可能的数据结构-树（它当前是二进制的，但不一定是）

公共类堆栈溢出\u 6915554
{
[数据合同]
[KnownType（typeof（LeafExpression））]
[KnownType（typeof（BinaryExpression））]
公共类表达式
{
}
[数据合同]
公共类表达式：表达式
{
[数据成员]
公共字符串名称；
}
[数据合同]
公共类二进制表达式：表达式
{
[数据成员]
公共二进制运算符；
[数据成员]
公众表达左；
[数据成员]
公众表达权；
}
公共枚举二进制运算符
{
以及，
或
}
公共静态无效测试（）
{
列表表达式=新列表（）；
添加（新的二进制表达式）
{
左=新的二进制表达式
{
左=新的叶表达式{Name=“A”}，
运算符=二进制运算符。和，
右=新的叶表达式{Name=“B”}，
},
运算符=二进制运算符。或，
右=新的二进制表达式
{
左=新的叶表达式{Name=“C”}，
运算符=二进制运算符。和，
Right=新的leaf表达式{Name=“D”}，
}
});
添加（新的二进制表达式）
{
左=新的叶表达式{Name=“E”}，
运算符=二进制运算符。或，
右=新的叶表达式{Name=“F”}
});
Add（新的LeafExpression{Name=“G”}）；
XmlWriterSettings ws=新的XmlWriterSettings
{
缩进=真，
缩进字符=”，
编码=新的UTF8编码（错误），
OmitXmlDeclaration=true，
};
MemoryStream ms=新的MemoryStream（）；
XmlWriter w=XmlWriter.Create（ms，ws）；
DataContractSerializer dcs=新的DataContractSerializer（ty）
public class StackOverflow_6915554
{
    [DataContract]
    [KnownType(typeof(LeafExpression))]
    [KnownType(typeof(BinaryExpression))]
    public class Expression
    {
    }

    [DataContract]
    public class LeafExpression : Expression
    {
        [DataMember]
        public string Name;
    }

    [DataContract]
    public class BinaryExpression : Expression
    {
        [DataMember]
        public BinaryOperator Operator;
        [DataMember]
        public Expression Left;
        [DataMember]
        public Expression Right;
    }

    public enum BinaryOperator
    {
        And,
        Or,
    }

    public static void Test()
    {
        List<Expression> expressions = new List<Expression>();
        expressions.Add(new BinaryExpression
        {
            Left = new BinaryExpression
            {
                Left = new LeafExpression { Name = "A" },
                Operator = BinaryOperator.And,
                Right = new LeafExpression { Name = "B" },
            },
            Operator = BinaryOperator.Or,
            Right = new BinaryExpression
            {
                Left = new LeafExpression { Name = "C" },
                Operator = BinaryOperator.And,
                Right = new LeafExpression { Name = "D" },
            }
        });

        expressions.Add(new BinaryExpression
        {
            Left = new LeafExpression { Name = "E" },
            Operator = BinaryOperator.Or,
            Right = new LeafExpression { Name = "F" }
        });

        expressions.Add(new LeafExpression { Name = "G" });

        XmlWriterSettings ws = new XmlWriterSettings
        {
            Indent = true,
            IndentChars = "  ",
            Encoding = new UTF8Encoding(false),
            OmitXmlDeclaration = true,
        };

        MemoryStream ms = new MemoryStream();
        XmlWriter w = XmlWriter.Create(ms, ws);

        DataContractSerializer dcs = new DataContractSerializer(typeof(List<Expression>));
        dcs.WriteObject(w, expressions);
        w.Flush();

        Console.WriteLine(Encoding.UTF8.GetString(ms.ToArray()));
    }
}