C# 如何修复此LINQ，使其将一对VAL视为不同的值？

我正在使用的数据库在两个整数列中存储一对双值

照此，Department是一个double，其值为42.12，但存储在Dept列（本例中为42）和Subdept列（本例中为12）中。不要问我为什么（因为你会失望；我不能告诉你为什么，因为我不知道）

我需要获取数据子集，例如“8.79和98.87之间的所有部门记录”

我有以下代码：

public IEnumerable<InventoryItem> GetDepartmentRange(double deptBegin, double deptEnd, string dbContext)
{
    LoadInventoryItems(dbContext);
    // Break the doubles into their component parts:
    var deptStartWhole = (int)Math.Truncate(deptBegin);
    var startFraction = (int)((deptBegin - deptStartWhole) * 100);
    var deptEndWhole = (int)Math.Truncate(deptEnd);
    var endFraction = (int)((deptBegin - deptEndWhole) * 100);

    return inventoryItems
        .Where(d => d.dept >= deptStartWhole)
        .Where(e => e.subdept >= startFraction)
        .Where(f => f.dept <= deptEndWhole)
        .Where(g => g.subdept >= endFraction)
        //.Where(g => g.subdept <= endFraction)
        .OrderBy(o => o.dept)
        .ThenBy(s => s.subdept);
}

public IEnumerable GetDepartmentRange（双deptBegin、双deptEnd、字符串dbContext）
{
LoadInventoryItems（dbContext）；
//将替身分解为其组成部分：
var deptStartWhole=（int）Math.Truncate（deptBegin）；
var startFraction=（int）（（deptBegin-deptStartTotal）*100）；
var deptEndWhole=（int）Math.Truncate（deptEnd）；
var endFraction=（int）（（deptBegin-deptEndWhole）*100）；
退回库存物品
其中（d=>d.dept>=deptStartWhole）
其中（e=>e.subdept>=startFraction）
其中（f=>f.dept g.subdept>=endFraction）
//.其中（g=>g.子部门o.部门）
.然后（s=>s.子部门）；
}

…但它不太管用-通过上面的查询（Depts介于8.79和98.87之间），它显示的Depts是98.88，这超出了我的要求

我尝试了注释掉的行，但这使它更糟（根本没有返回）

我的直觉告诉我，我可能需要一个“让”，但我不知道该怎么做

更新

---

建议：创建一个函数，该函数接受

deptNumber

和

deptSubNumber

，并返回一个

十进制

。然后，在

.Where（）

语句中使用该函数，将数字作为单个数字处理，而不是使用单独的逻辑（分别处理部门和子部门）。

您的端分数计算错误：

public IEnumerable<InventoryItem> GetDepartmentRange(double deptBegin, double deptEnd, string dbContext)
{
    LoadInventoryItems(dbContext);
    // Break the doubles into their component parts:
    int deptStartWhole = (int)Math.Truncate(deptBegin);
    int startFraction = (int)((deptBegin - deptStartWhole) * 100);
    int deptEndWhole = (int)Math.Truncate(deptEnd);
    int endFraction = (int)((deptEnd - deptEndWhole) * 100);

    return inventoryItems
        .Where(d => d.dept >= deptStartWhole)
        .Where(e => e.subdept >= startFraction)
        .Where(f => f.dept <= deptEndWhole)
        .Where(g => g.subdept >= endFraction)
        .OrderBy(o => o.dept)
        .ThenBy(s => s.subdept);
}

public IEnumerable GetDepartmentRange（双deptBegin、双deptEnd、字符串dbContext）
{
LoadInventoryItems（dbContext）；
//将替身分解为其组成部分：
int-deptstartwall=（int）Math.Truncate（deptBegin）；
int startFraction=（int）（（deptBegin-deptstartfall）*100）；
int deptEndWhole=（int）Math.Truncate（deptEnd）；
int endFraction=（int）（（deptEnd-deptEndWhole）*100）；
退回库存物品
其中（d=>d.dept>=deptStartWhole）
其中（e=>e.subdept>=startFraction）
其中（f=>f.dept g.subdept>=endFraction）
.OrderBy（o=>o.dept）
.然后（s=>s.子部门）；
}

此处的计算中使用了错误的变量：

var endFraction = (int)((deptBegin - deptEndWhole) * 100);

将

deptBegin

替换为

deptEnd

以修复此问题

使用以下代码进行测试时，进行此更改似乎会产生所需的值：

public void ShowDeptRange(double deptBegin, double deptEnd)
{
    // Break the doubles into their component parts:
    var deptStartW = (int)Math.Truncate(deptBegin);
    var deptStartF = (int)((deptBegin - deptStartW) * 100);
    var deptEndW = (int)Math.Truncate(deptEnd);
    var deptEndF = (int)((deptEnd - deptEndW) * 100);

    Console.WriteLine("{0}.{1}, {2}.{3}",
        deptStartW, deptStartF, deptEndW, deptEndF);
}

void Main()
{
    ShowDeptRange(8.79, 98.87);
}

public IEnumerable<InventoryItem> GetDepartmentRange(double deptBegin, double deptEnd, string dbContext)
{           
  LoadInventoryItems(dbContext);

  return inventoryItems
    .Where(d => ((d.dept * 100 + d.subdept) >= deptBegin * 100) &&       
                ((d.dept * 100 + d.subdept) <= deptEnd * 100))
    .OrderBy(o => o.dept)
    .ThenBy(s => s.subdept);
}

---

另外，它解决了查询逻辑的问题。

另一个建议是：是否可以在数据库中创建一个计算列，将两个字段简单地组合在数据库中，并以十进制形式返回

然后，在

.Where（）

语句中使用该函数，将数字作为单个数字进行处理，而不是使用单独的逻辑（分别处理部门和子部门）

---

接下来，C代码中的所有部门/子部门逻辑都将无效。

您的条件不正确。考虑如下：

int deptStartWhole = 8;
int startFraction = 79;
int deptEndWhole = 98;
int endFraction = 87;

你的情况是：

d.dept >= deptStartWhole && d.subdept >= startFraction
&& d.dept <= deptEndWhole && d.subdept <= endFraction

只有当

dept

完全相同时，才会选中

subdept

，否则只需选中

dept

部分，因为这是最重要的部分

return inventoryItems
    .Where(d => ((d.dept == deptStartWhole && d.subdept >= startFraction) || d.dept > deptStartWhole)
                && ((d.dept == deptEndWhole && d.subdept <= endFraction) || d.subdept < deptEndWhole))
    .OrderBy(o => o.dept)
    .ThenBy(s => s.subdept);

返回清单项目
其中（d=>（（d.dept==deptstarttall&d.subdept>=startFraction）| | d.dept>deptstarttall）
&&（（d.dept==部门整体和d.subdept o.dept）
.然后（s=>s.子部门）；

因为在您的示例中，分数乘以100，所以我假设

subdept

值只有两位数字。如果是这样，也许您可以尝试以下代码：

public void ShowDeptRange(double deptBegin, double deptEnd)
{
    // Break the doubles into their component parts:
    var deptStartW = (int)Math.Truncate(deptBegin);
    var deptStartF = (int)((deptBegin - deptStartW) * 100);
    var deptEndW = (int)Math.Truncate(deptEnd);
    var deptEndF = (int)((deptEnd - deptEndW) * 100);

    Console.WriteLine("{0}.{1}, {2}.{3}",
        deptStartW, deptStartF, deptEndW, deptEndF);
}

void Main()
{
    ShowDeptRange(8.79, 98.87);
}

public IEnumerable<InventoryItem> GetDepartmentRange(double deptBegin, double deptEnd, string dbContext)
{           
  LoadInventoryItems(dbContext);

  return inventoryItems
    .Where(d => ((d.dept * 100 + d.subdept) >= deptBegin * 100) &&       
                ((d.dept * 100 + d.subdept) <= deptEnd * 100))
    .OrderBy(o => o.dept)
    .ThenBy(s => s.subdept);
}

public IEnumerable GetDepartmentRange（双deptBegin、双deptEnd、字符串dbContext）
{           
LoadInventoryItems（dbContext）；
退回库存物品
其中（d=>（（d.dept*100+d.subdept）>=deptBegin*100）和
（（d.dept*100+d.subdept）o.dept）
.然后（s=>s.子部门）；
}

这有点帮助（它给了我两条以前没有返回的有效记录），但我仍然有伪造的/不需要的（98.88）记录。嗯。它只得到了.01以上吗？可能还有其他问题。我修复了我的帖子，包括你的修复。不，这导致我不再得到8.80（最低val为8.88），而我仍然有98岁。88@B.ClayShannon我的答案中的方法显示为“8.78，98.87”对我来说。它对你来说是一样的吗？如果是这样，我认为你的查询逻辑是不正确的。好吧，我可能不得不把它改成SQL语句，因为我不知道如何将它转换成LINQ。你不必转换任何东西，只要把它复制到你的

Where

调用中。你可以在那里使用

&

和

|

（这就是为什么你不需要所有这些

呼叫，只要使用
&
，一个就足够了。我已经更新了我的答案。谢谢你，Marcin；它仍然返回98.88记录。我在我的原始帖子中添加了一个尖叫镜头，显示返回的数据。@B.ClayShannon好的，你试过调试那个应用程序并检查计算出的值吗nd SQL查询的外观如何？最好将此建议添加到您以前的答案中。@Praveen已根据您的建议进行更新。我假设您指的是更新
.Where（）
语句。