在c＃中进行序列更新后重新排列通用列表

Question

假设我有一个通用列表，例如：

var categories = new List<Category>() {
    new Category() { sequence = 3, categoryName = "Category F" },
    new Category() { sequence = 1, categoryName = "Category S" },
    new Category() { sequence = 2, categoryName = "Category Z" },
    new Category() { sequence = 4, categoryName = "Category X" },
    new Category() { sequence = 5, categoryName = "Category V" }
};

我正在尝试用另一个替换给定的序列号，即列表中的更新项目，序号为＃2，编号为5，如下所示：

int currSeq = 2;
int newSeq = 5;
var item = categories.Find(a => a.sequence == currSeq);
item.sequence = newSeq;

如果newSeq没有变成重复，例如newSeq = 6，我可以做OrderBy：

categories = categories.OrderBy(c => c.sequence).ToList();

但问题是当它们变成重复时，我需要newSeq成为序列＃5并撞击其他重复序列＃5 + 1。

请帮助解决这个问题的任何指导。 谢谢。

更新：某些情况下新序列<旧序列，输出不符合要求。

情景A：

var categories = new List<Category>() {
    new Category() { sequence = 3, categoryName = "Category F" },
    new Category() { sequence = 1, categoryName = "Category S" },
    new Category() { sequence = 2, categoryName = "Category Z" },
    new Category() { sequence = 5, categoryName = "Category X" },
    new Category() { sequence = 6, categoryName = "Category V" }
};
int currSeq = 2;
int newSeq = 1;
var result = categories.UpdateSequence(currSeq,newSeq).OrderBy(x=>x.sequence);

输出方案A：

1: Category S
3: Category Z
4: Category F
5: Category X
6: Category V

期望的输出情景A：

1: Category Z
2: Category S
3: Category F
5: Category X
6: Category V

情景B：

int currSeq = 3;
int newSeq = 1;
var result = categories.UpdateSequence(currSeq,newSeq).OrderBy(x=>x.sequence);

输出方案B：

1: Category Z
2: Category S
4: Category F
5: Category X
6: Category V

期望的输出情景B：

1: Category F
2: Category S
3: Category Z
5: Category X
6: Category V

Answer 1

做elgonzo在评论中说的话。 另外，从宽间隔的序列号开始，即1000,2000,3000而不是1,2,3。 我不知道你的用例，但除非你重新排序，否则这将减少你必须做的序列号的“颠簸”次数。

Answer 2

假设您已经基于Sequence对列表进行了Sequence ，可以使用LINQ的FindIndex方法通过currSeq和newSeq查找元素的索引，然后使用RemoveAt和Insert将更新的元素放在正确的位置。

像这样的东西：

int currSeq = 2;
int newSeq = 5;
var oldIndex = categories.FindIndex(i => i.Sequence == currSeq);
var newIndex = categories.FindIndex(i => i.Sequence == newSeq);

if(oldIndex > -1)
{
    var oldItem = lst[oldIndex];
    oldItem.ID = newSeq;

    if(newIndex > -1)
    {
        newIndex = newIndex-1 < 0 ? 0 : newIndex - 1;    //in case the first element is the existing one
        categories.RemoveAt(oldIndex);
        categories.Insert(newIndex, oldItem);
    }
    else
    {
        categories = lst.OrderBy(i => i.ID).ToList();
    }
}

Answer 3

我认为这将解决您的问题。 但是当插入所有后续行时也会移动。 这对你好吗？

    var categories = new List<Category>() {
        new Category() { sequence = 3, categoryName = "Category F" },
        new Category() { sequence = 1, categoryName = "Category S" },
        new Category() { sequence = 2, categoryName = "Category Z" },
        new Category() { sequence = 4, categoryName = "Category X" },
        new Category() { sequence = 5, categoryName = "Category V" }
    };

    List<string> list = new List<string>();
    for (int i = 0; i < 6; i++)
    {
        list.Add("");
    }

    foreach (var item in categories)
    {
        list[item.sequence] = item.categoryName;
    }

    var removeFrom = 2;
    var removeTo = 5;

    list.Insert(removeTo, list[removeFrom]);
    list.RemoveAt(removeFrom);

Answer 4

根据评论更新并编辑OP。

假设您的Category类定义如下。

public class Category
{
    public int sequence{get;set;}
    public string categoryName{get;set;}
}

您可以按如下方式编写Update Sequence方法，以便在newValue <oldValue时获得所需的结果。

 public static List<Category> UpdateSequence(this List<Category> categories, int oldValue,int newValue)
 {
        var invalidState = -1;
        if(oldValue>newValue)
        {
            categories.Single(x=>x.sequence == oldValue).sequence = invalidState;
            if(categories.Any(x=>x.sequence == newValue))
            {
                categories = UpdateSequence(categories, newValue,newValue+1);
            }
            categories.Single(x=>x.sequence == invalidState).sequence = newValue;
        }
        else
        {
            if(categories.Any(x=>x.sequence == newValue))
            {
                categories = UpdateSequence(categories, newValue,newValue+1);
            }
            categories.Single(x=>x.sequence==oldValue).sequence = newValue;
        }
        return categories;
    }

输入

var categories = new List<Category>() {
    new Category() { sequence = 3, categoryName = "Category F" },
    new Category() { sequence = 1, categoryName = "Category S" },
    new Category() { sequence = 2, categoryName = "Category Z" },
    new Category() { sequence = 5, categoryName = "Category X" },
    new Category() { sequence = 6, categoryName = "Category V" }

场景1：

int currSeq = 2;
int newSeq = 1;
var result = categories.UpdateSequence(currSeq,newSeq).OrderBy(x=>x.sequence);

产量

1 Category Z 
2 Category S 
3 Category F 
5 Category X 
6 Category V 

情景2

int currSeq = 3;
int newSeq = 1;
var result = categories.UpdateSequence(currSeq,newSeq).OrderBy(x=>x.sequence);

输出继电器

1 Category F 
2 Category S 
3 Category Z 
5 Category X 
6 Category V