我正在进行一些单元测试，并且我想知道是否有任何方法可以测试列表是否按其包含的对象的属性排序。
现在我是这样做的，但我不喜欢它，我想要一个更好的方法。请问有人可以帮帮我吗？
// (fill the list)
List<StudyFeedItem> studyFeeds =
Feeds.GetStudyFeeds(2120, DateTime.Today.AddDays(-200), 20);
StudyFeedItem previous = studyFeeds.First();
foreach (StudyFeedItem item in studyFeeds)
{
if (item != previous)
{
Assert.IsTrue(previous.Date > item.Date);
}
previous = item;
}
如果你正在使用MSTest，你可能想要看一下CollectionAssert.AreEqual。
Enumerable.SequenceEqual是另一个在断言中可用的有用API。
在这两种情况下，你应该准备一个按照期望顺序包含期望列表的列表，然后将该列表与结果进行比较。
以下是一个示例：
var studyFeeds = Feeds.GetStudyFeeds(2120, DateTime.Today.AddDays(-200), 20);
var expectedList = studyFeeds.OrderByDescending(x => x.Date);
Assert.IsTrue(expectedList.SequenceEqual(studyFeeds));
Enumerable.Aggregate。 - Harald Coppoolse使用.NET 4.0的方法是使用Enumerable.Zip方法将列表与偏移一个位置的自身配对，这会将列表中的每个项与其后续项配对。然后你可以检查每对中条件是否为真，例如：
var ordered = studyFeeds.Zip(studyFeeds.Skip(1), (a, b) => new { a, b })
.All(p => p.a.Date < p.b.Date);
如果你使用的是较早版本的框架，你可以很容易地编写自己的Zip方法，类似于以下代码（参数验证和适用时的枚举器处理由读者自行完成）：
public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(
this IEnumerable<TFirst> first,
IEnumerable<TSecond> second,
Func<TFirst, TSecond, TResult> selector)
{
var e1 = first.GetEnumerator();
var e2 = second.GetEnumerator();
while (e1.MoveNext() & e2.MoveNext()) // one & is important
yield return selector(e1.Current, e2.Current);
}
<=。在集合中相邻的具有相同日期的项目不会使顺序无效。 - MaxNunit 2.5引入了CollectionOrderedContraint并提供了一种良好的语法来验证集合的顺序：
Assert.That(collection, Is.Ordered.By("PropertyName"));
无需手动排序和比较。
如果您的单元测试框架有用于比较集合相等性的助手方法，您应该能够像这样做（以NUnit为例）：
var sorted = studyFeeds.OrderBy(s => s.Date);
CollectionAssert.AreEqual(sorted.ToList(), studyFeeds.ToList());
assert 方法适用于任何 IEnumerable，但当两个集合都是 IList 或 "数组" 类型时，当断言失败时抛出的错误消息将包含第一个不在正确位置的元素的索引。
涉及对列表进行排序的发布的解决方案代价高昂 - 确定列表是否已排序可以在O(N)内完成。以下是一个扩展方法，可用于检查：
public static bool IsOrdered<T>(this IList<T> list, IComparer<T> comparer = null)
{
if (comparer == null)
{
comparer = Comparer<T>.Default;
}
if (list.Count > 1)
{
for (int i = 1; i < list.Count; i++)
{
if (comparer.Compare(list[i - 1], list[i]) > 0)
{
return false;
}
}
}
return true;
}
通过将> 0更改为< 0，可以轻松地实现相应的IsOrderedDescending。
>=是错误的，它会在[1, 1, 1, 2, 3]上返回false。修改以检测反向排序也很容易。 - Richard> 或任何运算符来比较元素。 - Sriram SakthivelIList<String>，但无法使用 IList<T> 或者 IEnumerable<T>。 - Tim SchmelterGreg Beech的回答虽然很好，但可以通过在Zip本身中进行测试来进一步简化。因此，不是：
var ordered = studyFeeds.Zip(studyFeeds.Skip(1), (a, b) => new { a, b })
.All(p => p.a.Date <= p.b.Date);
你可以简单地执行以下操作：
var ordered = !studyFeeds.Zip(studyFeeds.Skip(1), (a, b) => a.Date <= b.Date)
.Contains(false);
这样可以省去一个lambda表达式和一个匿名类型。
（根据我的观点，移除匿名类型也使代码更易读。）
(b => true)无论b的值是假还是真，都会返回真，我认为您想写的是(b => b)。请确认一下。 - Steve CadwalladerAll(b => b) 时，您会停顿一下，想一下我们正在进行一个“全为真”的测试，然后必须重新阅读前面的部分以查看我们要测试的实际条件。 - AnorZaken<=而不是<。相邻的相同值并不会使顺序无效。 - Maxif(studyFeeds.Length < 2)
return;
for(int i = 1; i < studyFeeds.Length;i++)
Assert.IsTrue(studyFeeds[i-1].Date > studyFeeds[i].Date);
for并没有完全消失！
怎么样：
var list = items.ToList();
for(int i = 1; i < list.Count; i++) {
Assert.IsTrue(yourComparer.Compare(list[i - 1], list[i]) <= 0);
}
其中yourComparer是一个实现了IComparer<YourBusinessObject>接口的YourComparer实例。这确保了枚举中的每个元素都小于下一个元素。
Linq的答案是：
您可以使用SequenceEqual方法来检查原始序列和排序后的序列是否相同。
var isOrderedAscending = lJobsList.SequenceEqual(lJobsList.OrderBy(x => x));
var isOrderedDescending = lJobsList.SequenceEqual(lJobsList.OrderByDescending(x => x));
不要忘记导入 System.Linq 命名空间。
此外:
我再次强调，本答案基于 Linq，您可以通过创建自定义扩展方法实现更高效的操作。
另外，如果有人仍然想使用 Linq 并检查序列是否按升序或降序排序，则可以像这样实现略微更高效的操作：
var orderedSequence = lJobsList.OrderBy(x => x)
.ToList();
var reversedOrderSequence = orderedSequence.AsEnumerable()
.Reverse();
if (lJobsList.SequenceEqual(orderedSequence))
{
// Ordered in ascending
}
else (lJobsList.SequenceEqual(reversedOrderSequence))
{
// Ordered in descending
}
public static System.ComponentModel.ListSortDirection? SortDirection<T>(this IEnumerable<T> items, Comparer<T> comparer = null)
{
if (items == null) throw new ArgumentNullException("items");
if (comparer == null) comparer = Comparer<T>.Default;
bool ascendingOrder = true; bool descendingOrder = true;
using (var e = items.GetEnumerator())
{
if (e.MoveNext())
{
T last = e.Current; // first item
while (e.MoveNext())
{
int diff = comparer.Compare(last, e.Current);
if (diff > 0)
ascendingOrder = false;
else if (diff < 0)
descendingOrder = false;
if (!ascendingOrder && !descendingOrder)
break;
last = e.Current;
}
}
}
if (ascendingOrder)
return System.ComponentModel.ListSortDirection.Ascending;
else if (descendingOrder)
return System.ComponentModel.ListSortDirection.Descending;
else
return null;
}
它可以检查序列是否已排序并确定方向：
var items = new[] { 3, 2, 1, 1, 0 };
var sort = items.SortDirection();
Console.WriteLine("Is sorted? {0}, Direction: {1}", sort.HasValue, sort);
//Is sorted? True, Direction: Descending
Any 和 First。这并不会迭代整个序列，而只是检查第一个元素。如果任何一个元素没有排序，它就会停止枚举并返回 false。 - Tim SchmelterGetEnumerable。如果这很昂贵，而且它确实很昂贵，那么你会比你需要的多调用三次。 - RawlingOrderBy + SequenceEqual 不是更低效吗？因为它需要在开始使用 SequenceEqual 之前对整个序列进行排序，而我的 foreach 可以立即比较顺序。此外，它还需要处理两次以检查两个方向，而我的循环只需要一次。 - Tim Schmelterusing(var e = items.GetEnumerator())与e.MoveNext()和e.Current）来避免使用Any()、Skip和First。 - Ivan Stoev
int x = 2, y = 2, z = x + y是否成功通过了Assert.IsTrue(z == 4)吧？你应该只对公共方法行为进行单元测试，仅此而已。所以，如果repository.GetItems(true)的预期行为是返回一个有序项目列表，则测试它。但不要测试items.OrderBy(x=>x,new YourComparer())是否确实对列表进行了排序。但是，请对YourComparer确实正确比较进行单元测试。 - jasonl.OrderBy(e => e).SequenceEqual(l)。 - a-ctor