C# 恒压不是一个常数

给定Msdn：常量表达式是可以在编译时完全计算的表达式

然而，在下面的示例代码中，我有一个contantExpression，它不能在编译时进行计算

我应该错过什么，但是什么

public class SomeClass
{
    public string Key { get; set; }
}

public static void Sample()
{
    var wantedKey = Console.ReadLine();
    Expression<Func<SomeClass, bool>> expression = c => c.Key == wantedKey;

    var maybeAConstantExpression = ((MemberExpression)((BinaryExpression)expression.Body).Right).Expression;

    //Both are true, so we have a constantExpression,righ and Value should be known
    Console.WriteLine(maybeAConstantExpression.NodeType == ExpressionType.Constant);
    Console.WriteLine(maybeAConstantExpression.GetType() == typeof(ConstantExpression));

    var constantExpression = ((ConstantExpression)maybeAConstantExpression);
    var constantValue = constantExpression.Value;

    //ConsoleApplication1.Program+<>c__DisplayClass0
    //Do not looks like a constant..this is a class...
    Console.WriteLine(constantValue);

    var fakeConstantValue = constantValue.GetType().GetField("wantedKey").GetValue(constantValue);
    //Return the value entered whith Console.ReadLine
    //This is not really known at compile time...
    Console.WriteLine(fakeConstantValue);
}

公共类SomeClass
{
公共字符串密钥{get；set；}
}
公共静态无效示例（）
{
var wantedKey=Console.ReadLine（）；
Expression=c=>c.Key==wantedKey；
var maybeAConstantExpression=（（MemberExpression）（（BinaryExpression）expression.Body）.Right.expression；
//这两个都是真的，所以我们有一个恒常的表达式，righ和Value应该是已知的
Console.WriteLine（可能是beaconstantexpression.NodeType==ExpressionType.Constant）；
Console.WriteLine（可能是ConstantExpression.GetType（）==typeof（ConstantExpression））；
var constantExpression=（（constantExpression）可能是constantExpression）；
var constantValue=ConstantPression.Value；
//控制台应用程序1.程序+c__显示类0
//不要看起来像常数…这是一个类。。。
控制台写入线（constantValue）；
var fakeConstantValue=constantValue.GetType（）.GetField（“wantedKey”）.GetValue（constantValue）；
//返回使用Console.ReadLine输入的值
//这在编译时是未知的。。。
控制台写入线（假常量值）；
}

const是可以在编译时进行计算的东西。

ConstantExpression

仅表示一个固定值。这可能来自编译时，但它不是必需的，而且通常不是

常量表达式（在C语言意义上）和

常量表达式

（运行时对象）之间存在差异

在您的例子中，

constantValue

代表捕获上下文-提升

wantedKey

的静默类。基本上，该代码是（通过编译器）：

你不能说{
公共字符串wantedKey；//是，公共字段
}
...
静态孔隙样本（）
{
var ctx=新的恐怖分子，你不能说（）；
ctx.wantedKey=Console.ReadLine（）；
var p=表达式参数（typeof（SomeClass），“c”）；
表情=
Lambda(
表达式。相等(
表达式.PropertyOrField（p，“键”），
Expression.PropertyOrField(
表达式常数（ctx），“wantedKey”）
)，p）；
);
}

或者非常接近的东西

但它可能只是：

string wantedKey = Console.ReadLine();
var p = Expression.Parameter(typeof(SomeClass), "c");
Expression<Func<SomeClass, bool>> expression =
    Expression.Lambda<Func<SomeClass, bool>>(
        Expression.Equal(
            Expression.PropertyOrField(p, "Key"),
            Expression.Constant(wantedKey, typeof(string))
            ), p);

string wantedKey=Console.ReadLine（）；
var p=表达式参数（typeof（SomeClass），“c”）；
表情=
Lambda(
表达式。相等(
表达式.PropertyOrField（p，“键”），
Expression.Constant（wantedKey，typeof（string））
)，p）；

---

如果您使用

Expresion

API（即如上所述）手动编写它作为常量表达式，则您的“maybeaconstantedpression”应保持常量值，但不是，它依赖于运行时的控制台读取行；因此，ConstantPression将不会在编译时进行计算。因此，在您的第一个代码示例中，Expression.Constant（ctx）如何可以是常量？这是一个可怕的例子，你不能说，不？@Toto再次，我明确地说，它不是语言意义上的“常数”。它是

表达式

意义上的常数，因为它表示固定值（与参数等相对）；但该固定值是在运行时提供的

Expression

是一个运行时API。@Toto需要澄清的是-在第一个示例中，我所做的只是写了一行

Expression Expression=c=>c.Key==wantedKey，但以编译器执行itOk的方式，thx。不一定要让Compility消化这个响应，我当然需要再次使用表达式101:）@Toto，但是是的，它引用了
的一个实例，你不能说
——或者正如编译器所说，
c_udisplayClass0
——简单地说：我不能把它放在示例中，因为它不会编译
string wantedKey = Console.ReadLine();
var p = Expression.Parameter(typeof(SomeClass), "c");
Expression<Func<SomeClass, bool>> expression =
    Expression.Lambda<Func<SomeClass, bool>>(
        Expression.Equal(
            Expression.PropertyOrField(p, "Key"),
            Expression.Constant(wantedKey, typeof(string))
            ), p);