C# 重排序中间序列的重新排序方法

列出具有“TruckNumber”属性的简单对象。大多数情况下，它们是按升序排列的，如1、2、3、4、8、11

问题是，有时，im获取数据的系统会识别多个具有相同卡车编号的对象。例如：1、2、3、3、4、5、6、7、8、9

我需要一种方法将该列表转换为此
1,2,3,4,5,6,7,8,9,10,11

这是未知的，但我认为我还需要处理存在多个重复TruckNumber值的“集合”的情况。 例如：1、2、3、3、4、5、6、7、7、7、8、9 会变成1，2，4，5，6，7，8，9，10，11，12，13

---

但是，在上面的示例中，卡车编号为1、2的对象需要保持该顺序，8、9也是如此。如果我理解正确，您可以这样做：

static IEnumerable<int> WithoutDuplicates(this IEnumerable<int> source)
{
    int sourceCount = source.Count();
    var distinct = source.OrderBy(i => i).Distinct();
    int distinctCount = distinct.Count();

    if (distinctCount == count)
    {
        return distinct;
    }

    // If items have been removed, append replacements
    int next = distinct.Max() + 1;
    int difference = sourceCount - distinctCount;
    return distinct.Union(Enumerable.Range(next, difference));
}

---

我想这会满足你的要求，尽管效率不高。使用

SortedDictionary

可能会更加优化

var startingList = new []
{
   new Thing { TruckNumber = 1 },   
   new Thing { TruckNumber = 2 },
   new Thing { TruckNumber = 2 },
   new Thing { TruckNumber = 3 },
   new Thing { TruckNumber = 4 },
   new Thing { TruckNumber = 5 },
   new Thing { TruckNumber = 5 },
   new Thing { TruckNumber = 6 },
   new Thing { TruckNumber = 7 }
}

var cleanedList = new List<Thing>();

var duplicates = new List<Thing>();

foreach (var thing in startingList) 
{
    if (cleanedList.Any(t => t.TruckNumber == thing.TruckNumber)) 
    {
        duplicates.Add(thing);
    }
    else 
    {
        cleanedList.Add(thing);
    }
}

var lastTruckNumber = cleanedList.Select(t => t.TruckNumber).Max();

foreach (var thing in duplicates) 
{
    var nextTruckNumber = lastTruckNumber + 1;
    thing.TruckNumber = nextTruckNumber;
    lastTruckNumber = nextTruckNumber;
}

return cleanedList;

var startingList=new[]
{
新事物{TruckNumber=1}，
新事物{TruckNumber=2}，
新事物{TruckNumber=2}，
新事物{TruckNumber=3}，
新事物{TruckNumber=4}，
新事物{TruckNumber=5}，
新事物{TruckNumber=5}，
新事物{TruckNumber=6}，
新事物{TruckNumber=7}
}
var cleanedList=新列表（）；
var duplicates=新列表（）；
foreach（启动列表中的变量）
{
if（cleanedList.Any（t=>t.TruckNumber==thing.TruckNumber））
{
重复。添加（事物）；
}
其他的
{
清除列表。添加（对象）；
}
}
var lastTruckNumber=cleanedList.Select（t=>t.TruckNumber）.Max（）；
foreach（重复的变量）
{
var nextTruckNumber=lastTruckNumber+1；
thing.TruckNumber=nextTruckNumber；
lastTruckNumber=nextTruckNumber；
}
返回清除列表；

您可以使用

选择

，它接受元素的索引：

class Truck { public int TruckNumber { get; set; } }

static void Main(string[] args)
{
    Truck[] trucks =
    {
        new Truck { TruckNumber = 1 }, new Truck { TruckNumber = 2 },
        new Truck { TruckNumber = 3 }, new Truck { TruckNumber = 3 }, new Truck { TruckNumber = 3 },
        new Truck { TruckNumber = 4 }, new Truck { TruckNumber = 5 }, new Truck { TruckNumber = 6 },
        new Truck { TruckNumber = 7 }, new Truck { TruckNumber = 8 }, new Truck { TruckNumber = 9 }
    };                                                                            
    var trucks2 = trucks.Select((tn, index) => { tn.TruckNumber = index + 1; return tn; });
}

---

如果有两个对象具有相同的

卡车编号

，保留哪一个重要吗？你能丢弃其中一个吗？如果您可以丢弃其中的任何一个，MoreLinq库有一个

DistinctBy

方法可以为您执行此操作。或者，等待重复项，您是否希望将它们重新编号并放在末尾？

class Truck { public int TruckNumber { get; set; } }

static void Main(string[] args)
{
    Truck[] trucks =
    {
        new Truck { TruckNumber = 1 }, new Truck { TruckNumber = 2 },
        new Truck { TruckNumber = 3 }, new Truck { TruckNumber = 3 }, new Truck { TruckNumber = 3 },
        new Truck { TruckNumber = 4 }, new Truck { TruckNumber = 5 }, new Truck { TruckNumber = 6 },
        new Truck { TruckNumber = 7 }, new Truck { TruckNumber = 8 }, new Truck { TruckNumber = 9 }
    };                                                                            
    var trucks2 = trucks.Select((tn, index) => { tn.TruckNumber = index + 1; return tn; });
}