C# 最小起订量设置赢得'；方法调用后进行隐式转换不起作用 对于这个问题，考虑（创建）接口： public interface ITestMe { string TakeInt64(long x); }

然后运行以下代码：

public void Test()
{
  var mock1 = new Mock<ITestMe>(MockBehavior.Strict);
  Expression<Func<ITestMe, string>> expr1 = x => x.TakeInt64(2);
  Console.WriteLine(expr1);
  mock1.Setup(expr1).Returns("OK");
  var s1 = mock1.Object.TakeInt64(2L); // OK

  var mock2 = new Mock<ITestMe>(MockBehavior.Strict);
  Expression<Func<ITestMe, string>> expr2 = x => x.TakeInt64(DateTime.Today.Year / 1000);
  Console.WriteLine(expr2);
  mock2.Setup(expr2).Returns("OK");
  var s2 = mock2.Object.TakeInt64(2L); // OK

  var mock3 = new Mock<ITestMe>(MockBehavior.Strict);
  Expression<Func<ITestMe, string>> expr3 = x => x.TakeInt64((int)(DayOfWeek)Enum.Parse(typeof(DayOfWeek), "Tuesday"));
  Console.WriteLine(expr3);
  mock3.Setup(expr3).Returns("OK");
  var s3 = mock3.Object.TakeInt64(2L); // OK

  var mock4 = new Mock<ITestMe>(MockBehavior.Strict);
  Expression<Func<ITestMe, string>> expr4 = x => x.TakeInt64(GetInt32());
  Console.WriteLine(expr4);
  mock4.Setup(expr4).Returns("OK");
  //var s4 = mock4.Object.TakeInt64(2L); // MockException, All invocations on the mock must have a corresponding setup.

  var mock5 = new Mock<ITestMe>(MockBehavior.Strict);
  Expression<Func<ITestMe, string>> expr5 = x => x.TakeInt64(int.Parse("2"));
  Console.WriteLine(expr5);
  mock5.Setup(expr5).Returns("OK");
  //var s5 = mock5.Object.TakeInt64(2L); // MockException, All invocations on the mock must have a corresponding setup.

  var mock6 = new Mock<ITestMe>(MockBehavior.Strict);
  Expression<Func<ITestMe, string>> expr6 = x => x.TakeInt64(GetInt32() + 0);
  Console.WriteLine(expr6);
  mock6.Setup(expr6).Returns("OK");
  var s6 = mock6.Object.TakeInt64(2L); // OK

  var mock7 = new Mock<ITestMe>(MockBehavior.Strict);
  Expression<Func<ITestMe, string>> expr7 = x => x.TakeInt64(1 * int.Parse("2"));
  Console.WriteLine(expr7);
  mock7.Setup(expr7).Returns("OK");
  var s7 = mock7.Object.TakeInt64(2L); // OK
}

static int GetInt32()
{
  return 2;
}

公共无效测试（）
{
var mock1=新的Mock（MockBehavior.Strict）；
表达式expr1=x=>x.TakeInt64（2）；
控制台写入线（expr1）；
mock1.Setup（expr1）.返回（“OK”）；
var s1=mock1.Object.TakeInt64（2L）；//确定
var mock2=新的Mock（MockBehavior.Strict）；
表达式expr2=x=>x.TakeInt64（DateTime.Today.Year/1000）；
控制台写入线（expr2）；
mock2.设置（expr2）.返回（“确定”）；
var s2=mock2.Object.TakeInt64（2L）；//确定
var mock3=新的Mock（MockBehavior.Strict）；
表达式expr3=x=>x.TakeInt64（（int）（DayOfWeek）Enum.Parse（typeof（DayOfWeek），“星期二”）；
控制台写入线（expr3）；
mock3.设置（expr3）.返回（“OK”）；
var s3=mock3.Object.TakeInt64（2L）；//确定
var mock4=新的Mock（MockBehavior.Strict）；
表达式expr4=x=>x.TakeInt64（GetInt32（））；
控制台写入线（expr4）；
mock4.Setup（expr4）.返回（“OK”）；
//var s4=mock4.Object.TakeInt64（2L）；//MockException，模拟上的所有调用都必须有相应的设置。
var mock5=新的Mock（MockBehavior.Strict）；
表达式expr5=x=>x.TakeInt64（int.Parse（“2”）；
控制台写入线（expr5）；
mock5.Setup（expr5）.返回（“OK”）；
//var s5=mock5.Object.TakeInt64（2L）；//MockException，模拟上的所有调用都必须有相应的设置。
var mock6=新的Mock（MockBehavior.Strict）；
表达式expr6=x=>x.TakeInt64（GetInt32（）+0）；
控制台写入线（expr6）；
mock6.Setup（expr6）.返回（“OK”）；
var s6=mock6.Object.TakeInt64（2L）；//确定
var mock7=新的Mock（MockBehavior.Strict）；
表达式expr7=x=>x.TakeInt64（1*int.Parse（“2”）；
控制台写入线（expr7）；
mock7.Setup（expr7）.返回（“OK”）；
var s7=mock7.Object.TakeInt64（2L）；//确定
}
静态int GetInt32（）
{
返回2；
}

在所有七种情况下，我们创建一个表达式树，其中

TakeInt64

获取

int

（

Int32

），而不是

long

（

Int64

）。然而，众所周知，存在从

int

到

long

的隐式转换，这将出现在表达式树中（除了在

expr1

中，编译器为我们转换常量）

为什么上面的

s4

和

s5

案例不起作用？奇怪的是，正如您所看到的，如果我们添加

0

或通过

1

多次添加

s6

和

s7

，这是有效的（即使类型仍然是

int

，隐式转换为

long

）

---

请在3000年前回答，因为case

expr2

我认为这是Moq中的一个错误。相关代码在中。具体来说，

Convert

从表达式中删除，以便进一步检查。当剩余的最顶层表达式节点是方法调用时，将延迟计算该节点。当剩下的表达式不是方法调用时，整个表达式（包括

Convert

！）将被急切地求值

这意味着使用惰性求值时，比较是在没有

Convert

和

对象的情况下进行的。Equals（2，2L）

是

false

。但是，对于急切的求值，会考虑

转换

，因此代码可以正常工作

我已经做了，这似乎为我解决了这个问题

---

（哇，我差点以为我赶不上了。）

真是太酷了。一个承认我发现了一个bug的答案，以及一个修复了这个问题的提交（尽管我自己没有检查）。