C#更改对象'；s顺序和同一类别中所有同级的顺序

我使用具有参数顺序（int）的对象处理迷你CMS。假设我有10个对象，每个对象都有自己的从1到10的顺序

我想将第三个元素移动到第八个位置，因此第三个元素应该得到位置（顺序）8，而第八个元素被设置为7和7-6以及6-5，因此设置为1

反之亦然：如果我将8元素移动到2的位置，那么8元素的顺序是2得到3，3得到4，所以在查询之前

我写了一个扭曲的代码，当加载时，它是错误的，并产生了不同于我所希望的结果。有人会遇到这样的问题吗

对不起，我说的是英语，这是我的代码：

 public static void UpdateJsTreeOrder(this IDocumentSession session, string pageId, string parent, string element)
    {

        var pages = session.Query<Page>().Where(x => x.ParentPageId == parent);
        var orderList = pages.Select(x => x.Order).Take(1024).ToList();
        var page = session.Load<Page>(pageId);

        if (element == null)
        {

            var subList = pages.Where(x => x.Order != page.Order).Take(1024).ToList();
            foreach (var item in subList)
            {
                item.Order++;
                session.Store(item);
            }
            page.Order = 1;
            session.Store(page);
            return;
        }


        var newOrder = session.Load<Page>(element).Order;


        if (!orderList.Any())
        {
            //its the first item
        }

        //last item 
        if (newOrder == orderList.Max())
        {
            var subList = pages.Where(x => x.Order <= newOrder && x.Order != page.Order).Take(1024).ToList();
            foreach (var item in subList)
            {
                item.Order--;
                session.Store(item);
            }
        }
        //first item
        else if (newOrder == orderList.Min())
        {
            var subList = pages;
            foreach (var item in subList)
            {
                item.Order--;
                session.Store(item);
            }
        }
        //int the middle
        else
        {
            var subList = pages.Where(x => x.Order >= newOrder || x.Order == newOrder).Take(1024).ToList();
            foreach (var item in subList)
            {
                item.Order--;
                session.Store(item);
            }
        }
        page.Order = newOrder;
        session.Store(page);
    }

public static void UpdateJsTreeOrder（此IDocumentSession会话、字符串pageId、字符串父级、字符串元素）
{
var pages=session.Query（），其中（x=>x.ParentPageId==parent）；
var orderList=pages.Select（x=>x.Order）.Take（1024.ToList（）；
var page=session.Load（pageId）；
if（元素==null）
{
var subList=pages.Where（x=>x.Order！=page.Order）.Take（1024.ToList（）；
foreach（子列表中的var项）
{
item.Order++；
会话。存储（项目）；
}
页面顺序=1；
会话存储（第页）；
返回；
}
var newOrder=session.Load（element.Order）；
如果（！orderList.Any（））
{
//这是第一项
}
//最后一项
if（newOrder==orderList.Max（））
{
var subList=pages.Where（x=>x.Order x.Order>=newOrder | | x.Order==newOrder）.Take（1024）.ToList（）；
foreach（子列表中的var项）
{
项目.订单--；
会话。存储（项目）；
}
}
page.Order=newOrder；
会话存储（第页）；
}

如果您正在使用LINQ（看起来是），并且有一个可以操作的集合，那么以下内容可能适合您：

    int oldOrder = 8;
    int newOrder = 3;

    if (newOrder < oldOrder) {
        SmallBit moving = collection.Where(c => c.Order == oldOrder).First();
        collection.Where(c => c.Order >= newOrder && c.Order < oldOrder).ToList().ForEach(c => c.Order += 1);
        moving.Order = newOrder;

    } else {
        SmallBit moving = collection.Where(c => c.Order == oldOrder).First();
        collection.Where(c => c.Order > oldOrder && c.Order <= newOrder).ToList().ForEach(c => c.Order -= 1);
        moving.Order = newOrder;

    }

intoldorder=8；
int newOrder=3；
如果（新订单<旧订单）{
SmallBit moving=collection.Where（c=>c.Order==oldOrder.First（）；
其中（c=>c.Order>=newOrder和&c.Orderc.Order+=1）；
moving.Order=newOrder；
}否则{
SmallBit moving=collection.Where（c=>c.Order==oldOrder.First（）；
其中（c=>c.Order>oldOrder&&c.Order c.Order-=1）；
moving.Order=newOrder；
}

编辑：

SmallBit

在本例中，它只是

页面

对象-我已经在小提琴中重命名了它。

如果您正在使用LINQ（看起来是），并且有一个可以操作的集合，以下内容可能适合您：

    int oldOrder = 8;
    int newOrder = 3;

    if (newOrder < oldOrder) {
        SmallBit moving = collection.Where(c => c.Order == oldOrder).First();
        collection.Where(c => c.Order >= newOrder && c.Order < oldOrder).ToList().ForEach(c => c.Order += 1);
        moving.Order = newOrder;

    } else {
        SmallBit moving = collection.Where(c => c.Order == oldOrder).First();
        collection.Where(c => c.Order > oldOrder && c.Order <= newOrder).ToList().ForEach(c => c.Order -= 1);
        moving.Order = newOrder;

    }

intoldorder=8；
int newOrder=3；
如果（新订单<旧订单）{
SmallBit moving=collection.Where（c=>c.Order==oldOrder.First（）；
其中（c=>c.Order>=newOrder和&c.Orderc.Order+=1）；
moving.Order=newOrder；
}否则{
SmallBit moving=collection.Where（c=>c.Order==oldOrder.First（）；
其中（c=>c.Order>oldOrder&&c.Order c.Order-=1）；
moving.Order=newOrder；
}

编辑：

SmallBit

在本例中，它只是

页面

对象-我在小提琴中重命名了它。

好的，因此有三个（有效）案例

• 项目不移动
• 项目移动到更大的订单，减少其他项目以腾出空间
• 项目移动到较小的订单，增加其他项目以腾出空间

因此，要解决每种情况：

private void MoveItem(List<Page> source, int fromOrder, int toOrder)
{
  if (fromOrder == toOrder)
  { return; }

  if (fromOrder < toOrder)
  {
    foreach(Page page in source)
    {
      bool match = page.Order == fromOrder;
      bool between = fromOrder < page.Order && page.Order <= toOrder;
      page.Order = match ? toOrder :
         between ? page.Order - 1 :
         page.Order;
    }
  }
  else
  {
    foreach(Page page in source)
    {
      bool match = page.Order == fromOrder;
      bool between = toOrder <= page.Order && page.Order < fromOrder;
      page.Order = match ? toOrder :
         between ? page.Order + 1 :
         page.Order;
    }
  }
}

private void MoveItem（列表源、int-fromOrder、int-toOrder）
{
if（fromOrder==toOrder）
{return；}
如果（从订单<到订单）
{
foreach（源代码中的页面）
{
bool match=page.Order==fromOrder；
bool between=fromOrder

项目不移动
项目移动到更大的订单，减少其他项目以腾出空间
项目移动到较小的订单，增加其他项目以腾出空间

因此，要解决每种情况：

private void MoveItem(List<Page> source, int fromOrder, int toOrder)
{
  if (fromOrder == toOrder)
  { return; }

  if (fromOrder < toOrder)
  {
    foreach(Page page in source)
    {
      bool match = page.Order == fromOrder;
      bool between = fromOrder < page.Order && page.Order <= toOrder;
      page.Order = match ? toOrder :
         between ? page.Order - 1 :
         page.Order;
    }
  }
  else
  {
    foreach(Page page in source)
    {
      bool match = page.Order == fromOrder;
      bool between = toOrder <= page.Order && page.Order < fromOrder;
      page.Order = match ? toOrder :
         between ? page.Order + 1 :
         page.Order;
    }
  }
}

private void MoveItem（列表源、int-fromOrder、int-toOrder）
{
if（fromOrder==toOrder）
{return；}
如果（从订单<到订单）
{
foreach（源代码中的页面）
{
bool match=page.Order==fromOrder；
bool between=fromOrder
public static void UpdateJsTreeOrder(int from,int to)
        {
            var pages = new List<int>() {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
            var item = pages.ElementAt(from);
            pages.RemoveAt(from);
            pages.Insert(to,item);
        }

publicstaticvoidupdatejstreeorder（int-from，int-to）
{
var pages=newlist（）{1,2,3,4,5,6,7,8,9,10}；
var项目=pages.ElementAt（从）；
页面。删除（从）；
页码。插入（至，项目）；
}

这只是一个可以合并到代码中的示例
我相信使用这样的Insert和RemoveAt语句可以获得所需的结果

public static void UpdateJsTreeOrder(int from,int to)
        {
            var pages = new List<int>() {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
            var item = pages.ElementAt(from);
            pages.RemoveAt(from);
            pages.Insert(to,item);
        }

publicstaticvoidupdatejstreeorder（int-from，int-to）
{
var pages=newlist（）{1,2,3,4,5,6,7,8,9,10}；
var项目=pages.ElementAt（从）；
页面。删除（从）；
页码。插入（至，项目）；
}

这只是一个示例，您可以将其合并到代码中
非常感谢！经过一个小小的修改！很高兴能提供帮助。祝您好运！非常感谢！经过一个小小的修改！很高兴能提供帮助。祝您好运！