C# 向上/向下移动项目

Question

我得到了一个包含项目的列表。他们都有一个“排序”列。排序列是int类型，并且是唯一的。

场景:

sort 1; sort 2; sort 3;

如果用户在列表中向上移动一个项目(例如排序 3)(例如到位置 1，这将给出排序值 1)，刚刚向上移动的项目下面的项目必须在列表中向下移动，并且应相应地应用排序编号。在这种情况下，所有移动的项目排序 - 1。

因此场景的最终状态如下所示:

sort 1 was sort 3; sort 3 was sort 2; sort 3 is now sort 1;

我如何使用 LINQ 执行此操作？这不仅仅是 3 项。它可以更多。

[编辑]

 public ActionResult Up(int id)
 {
    var item = dataContext.item.FirstOrDefault(x => x.item == id);

    return View(dataContext.items);
 }

Answer 1

这可能不是最容易理解的代码，但我已经对其进行了测试，它似乎可以按预期工作。

让我们设置一些数据。

var array = new [] 
{ 
    new { Sort = 1, Value = "foo1", },
    new { Sort = 2, Value = "foo2", },
    new { Sort = 3, Value = "foo3", },
    new { Sort = 4, Value = "foo4", },
};

var oldSort = 1;
var newSort = 3;

首先，根据新旧索引的位置将查询分为三部分，因此我们可以分别处理每种情况。

var q = 
    oldSort > newSort ? 
        array
            .Where(x => x.Sort >= newSort && x.Sort < oldSort)
            .Select(x => new { Sort = x.Sort + 1, Value = x.Value })
            .Union(array.Where(x => x.Sort < newSort || x.Sort > oldSort))
            .Union(array.Where(x => x.Sort == oldSort)
                        .Select(x => new { Sort = newSort, Value = x.Value }))
            : 
    oldSort < newSort ?         
        array
            .Where(x => x.Sort <= newSort && x.Sort > oldSort)
            .Select(x => new { Sort = x.Sort - 1, Value = x.Value })
            .Union(array.Where(x => x.Sort > newSort || x.Sort < oldSort))
            .Union(array.Where(x => x.Sort == oldSort)
                        .Select(x => new { Sort = newSort, Value = x.Value }))
            :
    array;

将项目向下移动的结果(oldSort = 1，newSort = 3):

1 foo2
2 foo3 
3 foo1 
4 foo4 

向上移动项目的结果(oldSort = 4，newSort = 2):

1 foo1 
2 foo4 
3 foo2 
4 foo3 

更新:查询通过将一个序列分成三部分来工作

• 具有旧索引的项目成为具有新索引的项目；
• 旧索引和新索引之间的项目向上或向下移动；
• 其余的保留他们的索引。

结果是各部分的并集。

更新 2:查询适用于任意数量的项目，没有循环是有意的。

更新 3:这是使用 LINQ-to-Entities 进行查询的一种方法。

using (var context = new TestDBEntities())
{
    var array = context.TestTables;
    var q =
        oldSort > newSort ?
            array
                .Where(x => x.Sort >= newSort && x.Sort < oldSort)
                .Select(x => new { Sort = x.Sort + 1, Value = x.Value })
                .Union(array.Where(x => x.Sort < newSort || x.Sort > oldSort)
                            .Select(x => new { Sort = x.Sort, Value = x.Value }))
                .Union(array.Where(x => x.Sort == oldSort)
                            .Select(x => new { Sort = newSort, Value = x.Value }))
                :
        oldSort < newSort ?
            array
                .Where(x => x.Sort <= newSort && x.Sort > oldSort)
                .Select(x => new { Sort = x.Sort - 1, Value = x.Value })
                .Union(array.Where(x => x.Sort > newSort || x.Sort < oldSort)
                            .Select(x => new { Sort = x.Sort, Value = x.Value }))
                .Union(array.Where(x => x.Sort == oldSort)
                            .Select(x => new { Sort = newSort, Value = x.Value }))
                :
        array.Select(x => new { Sort = x.Sort, Value = x.Value });
}

区别在于类型现在是明确兼容的。