Question

我有一个列表，我希望按照与当前相反的顺序对结果进行排序，以模仿用户单击列标题超链接。目前，我有以下几点：

 dsList.Sort((x, y) => String.CompareOrdinal(x.DisplayName, y.DisplayName));

但这只是提升。我知道要做下降我会这样做：

 dsList.Sort((x, y) => String.CompareOrdinal(x.DisplayName, y.DisplayName)*-1);

但是，我不想检测它目前是什么，并决定要做什么。

有意义吗？

格拉西亚斯。

为了澄清，我不能使用Reverse，因为我有超过1列可以排序，所以我需要能够指定要排序的值。

以下有效，但不适用于空值。如果有空白，则排序会卡住。

  dsList.Sort((x, y) => String.CompareOrdinal(x.Surname, y.Surname) * (strB != null && (strA != null && String.Compare(strA, strB) == -1) ? -1 : 1));

Answer 1

为什么不使用Linq扩展程序Reverse()？这可以让您在不知道当前排序的情况下在升序和降序之间切换。如果要使用此功能，请确保引用System.Core库并在源文件顶部声明带有System.Linq的using指令。

另一种方法是创建一个继承自List并稍微修改它的类：

public class LazyReversingList<T> : IList<T>
{
    private Boolean m_SortedAscending;
    private List<T> m_InnerList;

    public Boolean IsReadOnly
    {
        get
        {
            return false;
        }
    }

    public Boolean SortedAscending
    {
        get
        {
            return m_SortedAscending;
        }
    }

    public Int32 Count
    {
        get
        {
            EnsureList();
            return m_InnerList.Count;
        }
    }

    public T this[Int32 index]
    {
        get
        {
            EnsureList();
            return m_InnerList[index];
        }
        set
        {
            EnsureList();
            m_InnerList[index] = value;
        }
    }

    private void EnsureList()
    {
        if (m_InnerList == null)
            m_InnerList = new List<T>();
    }

    public Boolean Contains(T item)
    {
        EnsureList();
        return m_InnerList.Contains(item);
    }

    public Boolean Remove(T item)
    {
        EnsureList();
        return m_InnerList.Remove(item);
    }

    public IEnumerator<T> GetEnumerator()
    {
        EnsureList();
        return m_InnerList.GetEnumerator();
    }

    public Int32 IndexOf(T item)
    {
        EnsureList();
        return m_InnerList.IndexOf(item);
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        EnsureList();
        return m_InnerList.GetEnumerator();
    }

    public void Add(T item)
    {
        EnsureList();
        m_InnerList.Add(item);
    }

    public void Clear()
    {
        EnsureList();
        m_InnerList.Clear();
    }

    public void CopyTo(T[] array, Int32 arrayIndex)
    {
        EnsureList();
        m_InnerList.CopyTo(array, arrayIndex);
    }

    public void Insert(Int32 index, T item)
    {
        EnsureList();
        m_InnerList.Insert(index, item);
    }

    public void RemoveAt(Int32 index)
    {
        EnsureList();
        m_InnerList.RemoveAt(index);
    }

    public void Reverse()
    {
        if (!m_SortedAscending)
        {
            m_InnerList.Sort((x, y) => String.CompareOrdinal(x.DisplayName, y.DisplayName));
            m_SortedAscending = true;
        }
        else
        {
            m_InnerList.Sort((x, y) => (String.CompareOrdinal(x.DisplayName, y.DisplayName) * -1));
            m_SortedAscending = false;
        }
    }
}

Answer 2

怎么样

dsList.Sort((x, y) => String.CompareOrdinal(x.DisplayName, y.DisplayName)*(dsList[0] < dsList[1]?-1:1));

编辑：在您的评论中，当存在重复或空值时，您似乎遇到了问题...这应该解决这个问题

dsList.Sort((x, y) => String.CompareOrdinal(x.DisplayName, y.DisplayName)*String.CompareOrdinal(dsList[0].DisplayName, dsList[dsList.Length-1].DisplayName));

Answer 3

如果您想要做的只是每次都反转当前的顺序，您应该考虑使用.Net的LINQ中提供的Reverse方法

OR

您可以简单地来回传递一个方向的值。这将允许将排序行为绑定到页面的所需状态，为此考虑隐藏字段。

按desc或asc排序列表，具体取决于当前的情况

3 个答案: