C#，如何获取列表或数组中的差异

我正在寻找使用LINQ计算数组或列表中两个项目之间差异的方法。
我认为ExtensionMethod是另一个很好的解决方案，但我想知道如何通过LINQ来实现它。
请帮帮我

var items = new List<int> { 238, 348, 274, 490, 459, 349 };

Console.WriteLine($"{items[0]} - 0 = {items[0]}"); 

for (int i = 1; i < items.Count; i++)
{
    Console.WriteLine($"{items[i]} - {items[i-1]} = {items[i] - items[i-1]}");
}

result:
238 - 0 = 238
348 - 238 = 110
274 - 348 = -74
490 - 274 = 216
459 - 490 = -31
349 - 459 = -110

---

谢谢。

不确定为什么需要这种逻辑，但在LINQ中实现这一点的一种方法是使用

Zip

，如下所示：

var items = new List<int> { 238, 348, 274, 490, 459, 349 };
var results = items.Prepend(0)
     .Zip(items, 
            (itemFromPrepended, itemFromOriginal) => 
            $"{itemFromOriginal} - {itemFromPrepended} = {itemFromOriginal - itemFromPrepended}");

var items=新列表{23834827490459349}；
var结果=项目。预结束（0）
.Zip（项目、，
（ItemFromPrepend，itemFromOriginal）=>
$“{itemFromOriginal}-{ItemFromPrepend}={itemFromOriginal-ItemFromPrepend}”）；

items.Prepend（0）

返回一个前面有

0

的列表（.即

{023834827449045949}

）

Zip

将获取这两个列表，并将提供的lambda应用于每个列表中的一个元素。我在那里提供的lambda只是将其格式化为字符串，您可以任意转换它。我还使lambda变量名更为详细，这样您就可以知道这些变量是什么了

确保可以通过使用LINQ

Aggregate

方法（ab？）来实现这一点：

var differences = items.Aggregate(new { Previous = 0, List = new List<int>()}, (aggregate, current) =>
{
    aggregate.List.Add(current - aggregate.Previous);
    return new { Previous = current, aggregate.List};
}).List;

但是使用

for

循环也没有什么错。我真的感觉到人们盲目地想用LINQ做任何事情

编辑：我看到您要求忽略第一个“怪异”输出，基本上跳过第一个值，这两种情况下都是这样：

var differences = items.Aggregate(new { Previous = (int?)null, List = new List<int>()}, (aggregate, current) =>
{
    if (aggregate.Previous.HasValue)
        aggregate.List.Add(current - aggregate.Previous.Value);
    return new { Previous = (int?)current, aggregate.List};
}).List;

int? previous = null;
items.ForEach(item =>
{
    if (previous.HasValue)
        Console.WriteLine($"{item} - {previous} = {item - previous}");
    previous = item;
});

var differences=items.Aggregate（new{Previous=（int？）null，List=new List（）}，（Aggregate，current）=>
{
if（聚合.Previous.HasValue）
聚合.List.Add（当前-聚合.Previous.Value）；
返回新的{Previous=（int？）current，aggregate.List}；
}).名单；
智力？previous=null；
items.ForEach（item=>
{
if（上一个.HasValue）
WriteLine（$“{item}-{previous}={item-previous}”）；
先前=项目；
});

@Christoph Lütjen谢谢你的建议。我试着解决了它

int last = 0;
items.Aggregate(last, (prev,next) => {
    Console.WriteLine($"{next} - {prev} = {next - prev}");
    return next; 
}, next => last); 

result:
238 - 0 = 238
348 - 238 = 110
274 - 348 = -74
490 - 274 = 216
459 - 490 = -31
349 - 459 = -110

@安德烈·莫尔顿也谢谢你

var result = string.Join(Environment.NewLine, items.Zip(items.Skip(1), 
    (a, b) => $"{b} - {a} = {b - a}"));
Console.WriteLine(result);

//result
348 - 238 = 110
274 - 348 = -74
490 - 274 = 216
459 - 490 = -31
349 - 459 = -110

---

您可以编写扩展方法：谢谢您的评论。但我想通过LINQ了解它。您可以使用

Aggregate（）

，或者这可能会有所帮助：@JaeChulKim这些值是唯一的吗？您的第一行238-0没有意义，或者没有逻辑。您的程序无法给出您显示的结果。OP澄清了他们不需要“238-0”行，所以只要

string.Join（“\r\n”，items.Zip（items.Skip（1），（a，b）=>$”{b}-{a}={b-a}”）

就可以使用

Zip

@AndrewMorton获得答案，谢谢。我错过了评论。是的，你的评论应该能解决这个问题case@AndrewMorton谢谢。如果您传入一个累加器函数而不是内联编写代码，那么使用Aggregate（）将非常有意义。例如，

items.Aggregate（MyAccumerators.DiffWithLast）

。与扩展功能相比，您可以保持intellisense的干净。

int last = 0;
items.Aggregate(last, (prev,next) => {
    Console.WriteLine($"{next} - {prev} = {next - prev}");
    return next; 
}, next => last); 

result:
238 - 0 = 238
348 - 238 = 110
274 - 348 = -74
490 - 274 = 216
459 - 490 = -31
349 - 459 = -110

var result = string.Join(Environment.NewLine, items.Zip(items.Skip(1), 
    (a, b) => $"{b} - {a} = {b - a}"));
Console.WriteLine(result);

//result
348 - 238 = 110
274 - 348 = -74
490 - 274 = 216
459 - 490 = -31
349 - 459 = -110