在我的项目中，我经常使用Linq's Sum()。它由MySQL上的nhibernate提供支持。在我的Session Factory中，我明确要求nhibernate在涉及decimals时精确处理8位小数：

不过，我发现.Sum()把数字四舍五入到小数点后5位：

var opasSum = opasForThisIp.Sum(x => x.Amount); // Amount is a decimal

在上面的声明中，opaSum等于2.46914，而它应该是2.46913578(直接在mysql上计算)。opasForThisIp为IQueryable型。

当涉及到decimals时，我需要所有的linq计算来处理8个小数位。

有什么解决办法吗？

编辑1：我发现var opasSum = Enumerable.Sum(opasForThisIp, opa => opa.Amount);可以产生正确的结果，但问题仍然存在，为什么.Sum()会对结果进行四舍五入，如何解决？

编辑2:生成的SQL似乎有问题：

编辑3:var opasSum = opasForThisIp.ToList().Sum(x => x.Amount);也会产生正确的结果。

编辑4：将IQueryable转换为IList使原始查询：var opasSum = opasForThisIp.Sum(x => x.Amount);生效。

x.amount正在从"linq to sql"转换为低精度的最小类型，因为您的集合是可查询的。

有几种解决方法，其中最简单的方法是将集合的类型更改为ilist，或者对集合调用tolist()，强制linq查询作为linq to对象运行。

注：如果您不想通过从IQueryable移走而丢失延迟的执行，可以尝试在Linq查询中将金额强制转换为十进制。

来自msdn decimal和numeric(Transact-SQL)：

In Transact-SQL statements, a constant with a decimal point is
automatically converted into a numeric data value, using the minimum
precision and scale necessary. For example, the constant 12.345 is
converted into a numeric value with a precision of 5 and a scale of 3.

编辑(包括对不同.NET集合类型的详细说明：

摘自这个问题的答案。

IQueryable is intended to allow a query provider (for example, an
ORM like LINQ to SQL or the Entity Framework) to use the expressions
contained in a query to translate the request into another format. In
other words, LINQ-to-SQL looks at the properties on the entities that
you're using along with the comparisons you're making and actually
creates a SQL statement to express (hopefully) an equivalent request.

IEnumerable is more generic than IQueryable (though all
instances of IQueryable implement IEnumerable) and only defines
a sequence. However, there are extension methods available within the
Enumerable class that define some query-type operators on that
interface and use ordinary code to evaluate these conditions.

List is just an output format, and while it implements
IEnumerable, is not directly related to querying.

In other words, when you're using IQueryable, you're defining and
expression that gets translated into something else. Even though
you're writing code, that code never gets executed, it only gets
inspected and turned into something else, like an actual SQL query.
Because of this, only certain things are valid within these
expressions. For instance, you cannot call an ordinary function that
you define from within these expressions, since LINQ-to-SQL doesn't
know how to turn your call into a SQL statement. Most of these
restrictions are only evaluated at runtime, unfortunately.

When you use IEnumerable for querying, you're using
LINQ-to-Objects, which means you are writing the actual code that is
used for evaluating your query or transforming the results, so there
are, in general, no restrictions on what you can do. You can call
other functions from within these expressions freely.