使用LINQ查询简化流程

19

这是我的表格:

PupilNutrition

(学生营养)
Id     PupilId   NutritionId
1       10          100  
2       10          101

我的另一个表格营养

Id  Nutritioncategory  BatchId   NutritionRate   NutritionId   Operation
1       A                1         9000             100          1
2       B                1         5000             100          0
3       C                1         5000             100          1
4       D                2         6000             101          2           
5       E                2         7000             101          2         
6       F                2         8000             101          0          

这是一个用于存储最终费率的字段:

decimal Rate= 0;

案例1: 操作字段值为0且批次ID为1

 Rate= Rate + NutritionRate(i.e 5000 because for batch id 1 with condition 0 only 1 record is there).

案例2: 现在针对操作字段值为1和批次ID为1的情况

Here i want to sum up both the value i.e(10000 and 5000) but during addition if sum of both is greater than 10000 then just take 10000 else take sum like this:
if(9000 + 5000 > 10000)
  Rate= 10000
else
    Rate=Rate + (Addition of both if less than 10000).

案例3:现在针对操作字段值为0和批次ID为2的情况

 Rate= Rate + NutritionRate(i.e 8000 because for batch id 1 with condition 0 only 1 record is there).

案例 4: 现在针对操作字段值为2和批次ID为2的情况

Here I will select Maximum value from Nutrition Rate field if there are 2 records:
Rate=Rate - (Maximum value from 6000 and 7000 so will take 7000).

我的Class文件:

 public partial class PupilNutrition
    {
        public int Id { get; set; }
        public int PupilId { get; set; }
        public int NutritionId { get; set; }
    }

 public partial class Nutrition
    {
        public int Id { get; set; }
        public string Nutritioncategory { get; set; }
        public decimal NutritionRate  { get; set; }
        public Nullable<int> NutritionId { get; set; }
    }

这是我的做法:
batchId=1 or 2;//
 List<int> NutritionId = db.PupilNutrition.Where(x => PupilId  == 10).Select(c => c.NutritionId).ToList();  //output 100,101
 var data = db.Nutrition.Where(x => x.BatchId == batchId && NutritionId.Contains(x.NutritionId.Value)).ToList();

我尝试过这样做,但这是一项繁琐的工作:
var data1=data.where(t=>t.Operation==0);
Rate= Rate + data1.Sum(p => p.NutritionRate);

同样适用于操作1:
var data2=data.where(t=>t.Operation==1);
This is left because here i need to sum up 2 value if two records are there as shown in my above cases and if sum is greater than 10000 than select 10000 else select sum.

同样的,对于操作2:
var data3=data.where(t=>t.Operation==2);
Rate= Rate - data3.Max(p => p.NutritionRate);

我认为我已经完成了这个劳动过程,但我想使用linq查询来更好地完成它。

所以有人可以帮我简化整个linq查询过程或者其他更好的方式,并提供Operation Value 2的解决方案吗?


1
请澄清一下 - 您是想要4个不同的结果,还是一个结果,即case1+case2+case3+case4? - Rob
@Rob:最终结果如下:情况1(费率)+情况2(费率)+情况3(费率)。只有三种情况,即0、1、2。 - Learning-Overthinker-Confused
4个回答

11

最短不一定是最好的。

个人认为,单个复杂的LINQ语句难以阅读和调试。

这是我会做的:

    public decimal CalculateRate(int pupilId, int batchId)
    {
        return db.Nutrition
            .Where(x => x.BatchId == batchId && db.PupilNutrition.Any(y => y.PupilId == pupilId && y.NutritionId == x.NutritionId))
            .GroupBy(x => x.Operation)
            .Select(CalculateRateForOperationGroup)
            .Sum();
    }

    public decimal CalculateRateForOperationGroup(IGrouping<int, Nutrition> group)
    {
        switch (group.Key)
        {
            case 0:
                // Rate = Sum(x)
                return group.Sum(x => x.NutritionRate);
            case 1:
                // Rate = Min(10000, Sum(x))
                return Math.Min(10000, group.Sum(x => x.NutritionRate));
            case 2:
                // Rate = -Max(x)
                return -group.Max(x => x.NutritionRate);
            default:
                throw new ArgumentException("operation");
        }
    }

那么您可以按照以下方式使用:

var rateForFirstBatch = CalculateRate(10, 1);
var rateForSecondBatch = CalculateRate(10, 2);

它不允许我像这样使用:.Select(CalculateRateForOperationGroup) - Learning-Overthinker-Confused
1
你能具体说明错误信息吗?我在我的电脑上成功运行了这段代码。你可以尝试用.Select(x => CalculateRateForOperationGroup(x))替换.Select(CalculateRateForOperationGroup) - Kaspars Ozols

5

使用分组更容易:

int sumMax = 10000;
var group = from n in nutrition
    group n by new { n.Operation, n.BatchId } into g
    select new { BatchId = g.Key.BatchId, 
        Operation = g.Key.Operation, 
        RateSum = g.ToList().Sum(nn => nn.NutritionRate), 
        RateSumMax = g.ToList().Sum(nn => nn.NutritionRate) > sumMax ? sumMax : g.ToList().Sum(nn => nn.NutritionRate), 
        RateMax = g.ToList().Max(nn => nn.NutritionRate) };
var result = from g in group
    select new {
        BatchId = g.BatchId,
        Operation = g.Operation,
        Rate = g.Operation == 1 ? g.RateSumMax :
               g.Operation == 2 ? g.RateMax :
               g.RateSum //default is operation 0
    };
var totalRate = result.Sum(g=>g.Rate);

你在查询中没有考虑我的条件(0、1、2),比如当有0时,当有1时,当有2时(最大值)。 - Learning-Overthinker-Confused
我在我的回答中添加了条件,但我不确定是否理解了您的处理要求(这就是为什么我起初没有将其包含在内)。 - Niels V
你需要在第一个查询中检查你在上一个查询中所检查的条件。例如,在执行求和或选择最大值之前,你需要检查操作值是否为0、1或2。例如:RateSum = g.Condition==1 ? g.ToList().Sum(nn => nn.NutritionRate)。 - Learning-Overthinker-Confused
OP说你需要减去最大值,而不是加上它。 - Kaspars Ozols

4

更新 这个查询看起来应该可以为您完成工作。请注意,我没有测试过它,所以可能会有一两个语法错误,但是思路似乎是正确的。

var rate = db.Nutrition
        .GroupBy(n => new { n.BatchId, n.Operation })
        .Select(g => g.Sum(n => n.NutritionRate) > 10000 ? 10000 : g.Sum(n => n.NutritionRate))
        .Sum();

或者,如果您想针对每种情况进行查询:
rate = db.Nutrition
            .Where(n => n.BatchId == 1 && n.Operation == 0)
            .Sum(n => n.NutritionRate); //Case 1

rate += Math.Min(
            10000,  //Either return 10,000, or the calculation if it's less than 10,000
            db.Nutrition
            .Where(n => n.BatchId == 1 && 
                        n.Operation == 1) //filter based on batch and operation
            .Sum(n => n.NutritionRate) //take the sum of the nutrition rates for that filter
        ); //Case 2

rate += db.Nutrition
            .Where(n => n.BatchId == 2 && n.Operation == 0)
            .Sum(n => n.NutritionRate); //Case 3

rate += Math.Min(
            10000,  //Either return 10,000, or the calculation if it's less than 10,000
            db.Nutrition
            .Where(n => n.BatchId == 2 && 
                        n.Operation == 2) //filter based on batch and operation
            .Sum(n => n.NutritionRate) //take the sum of the nutrition rates for that filter
        ); //Case 4

能不能像 Niels V 一样在单个 Linq 查询中完成,因为我想尽量减少计算步骤。 - Learning-Overthinker-Confused

4

试试这个。我将查询分解以使其更清晰,但是您可以将其组合在一个语句中。

        //// Join the collection to get the BatchId
        var query = nutritionColl.Join(pupilNutrition, n => n.NutritionId, p => p.NutritionId, (n, p) => new { BatchId = p.Id, Nutrition = n });

        //// Group by BatchId, Operation
        var query1 = query.GroupBy(i => new { i.BatchId, i.Nutrition.Operation });


        //// Execute Used cases by BatchId, Operation
        var query2 = query1.Select(grp =>
                {
                    decimal rate = decimal.MinValue;
                    if (grp.Count() == 1)
                    {
                        rate = grp.First().Nutrition.NutritionRate;
                    }
                    else if (grp.First().BatchId == 1)
                    {
                        var sum = grp.Sum(i => i.Nutrition.NutritionRate);
                        rate = sum > 10000 ? 10000 : sum;
                    }
                    else
                    {
                        rate = grp.Max(i => i.Nutrition.NutritionRate);
                    }

                    return new { BatchId = grp.First().BatchId, Operation = grp.First().Nutrition.Operation, Rate = rate };
                }
        );

        //// try out put
        foreach (var item in query2)
        {
            Console.WriteLine("{0}  {1} {2} ", item.Operation, item.BatchId, item.Rate);
        }

希望能对您有所帮助


你应该使用 grp.Key.BatchId 而不是 grp.First().BatchId - Kaspars Ozols
OP说你需要减去最大值,而不是加上它。应该是 rate = -grp.Max(i => i.Nutrition.NutritionRate); - Kaspars Ozols
@Kaspars Ozols,我建议您仔细阅读该语句。 "在这里,如果有两条记录,我将从营养率字段中选择最大值:Rate = Rate-(6000和7000的最大值,因此将取7000)"他从哪里选取了7000? - D J
我重新阅读了该声明,它现在非常清晰明了。有两条记录匹配批次ID=2和选项=2。其中一条的比率为6000,另一条为7000。选择最大值并从总比率中减去。例如:比率=-7000 - Kaspars Ozols
你是否期望负数利率。其次,我认为这是连字符“-”,而不是减号。 - D J

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文,
原文链接