Assert.AreSequenceEqual 方法

定义

命名空间:: Microsoft.VisualStudio.TestTools.UnitTesting

程序集:: MSTest.TestFramework.dll

包:: MSTest.TestFramework v4.4.0

包:: MSTest.TestFramework v4.3.0

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

重载

名称	说明
AreSequenceEqual(IEnumerable, IEnumerable, String, String, String)	测试两个序列是否包含相同顺序的相等元素，如果没有，则会引发异常。
AreSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)	测试两个序列是否包含使用指定顺序语义的相等元素，如果未指定序列，则引发异常。
AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)	使用指定的比较器测试两个序列是否包含相同顺序的相等元素，如果没有，则引发异常。
AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)	测试两个序列是否包含使用指定的比较器和顺序语义的相等元素，如果未指定序列，则引发异常。
AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	测试两个跨度是否包含使用指定的比较器和顺序语义的相等元素，如果未指定范围，则引发异常。
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	测试两个跨度是否包含使用指定的比较器和顺序语义的相等元素，如果未指定范围，则引发异常。
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	测试两个内存区域是否包含使用指定的比较器和顺序语义的相等元素，如果未指定，则引发异常。
AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	测试两个内存区域是否包含使用指定的比较器和顺序语义的相等元素，如果未指定，则引发异常。
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	测试两个序列是否包含使用指定的比较器和顺序语义的相等元素，如果未指定序列，则引发异常。
AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)	使用指定的比较器测试两个跨度是否包含相同顺序的相等元素，如果没有，则引发异常。
AreSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)	测试两个跨度是否包含使用指定顺序语义的相等元素，如果未指定，则引发异常。
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)	使用指定的比较器测试两个跨度是否包含相同顺序的相等元素，如果没有，则引发异常。
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)	使用指定的比较器测试两个内存区域是否包含相同顺序的相同元素，如果未指定，则引发异常。
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)	测试两个跨度是否包含使用指定顺序语义的相等元素，如果未指定，则引发异常。
AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)	使用指定的比较器测试两个内存区域是否包含相同顺序的相同元素，如果未指定，则引发异常。
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)	测试两个内存区域是否包含使用指定顺序语义的相等元素，如果未指定，则引发异常。
AreSequenceEqual<T>(Memory<T>, Memory<T>, String, String, String)	测试两个内存区域是否包含相同顺序的相等元素，如果没有，则会引发异常。
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)	测试两个内存区域是否包含相同顺序的相等元素，如果没有，则会引发异常。
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)	测试两个跨度是否包含相同顺序的相等元素，如果没有，则会引发异常。
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)	测试两个序列是否包含相同顺序的相等元素，如果没有，则会引发异常。
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)	测试两个序列是否包含使用指定顺序语义的相等元素，如果未指定序列，则引发异常。
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)	使用指定的比较器测试两个序列是否包含相同顺序的相等元素，如果没有，则引发异常。
AreSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)	测试两个内存区域是否包含使用指定顺序语义的相等元素，如果未指定，则引发异常。
AreSequenceEqual<T>(Span<T>, Span<T>, String, String, String)	测试两个跨度是否包含相同顺序的相等元素，如果没有，则会引发异常。

AreSequenceEqual(IEnumerable, IEnumerable, String, String, String)

Source:: Assert.AreSequenceEqual.cs

测试两个序列是否包含相同顺序的相等元素，如果没有，则会引发异常。

public static void AreSequenceEqual(System.Collections.IEnumerable? expected, System.Collections.IEnumerable? actual, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * string * string * string -> unit

Public Shared Sub AreSequenceEqual (expected As IEnumerable, actual As IEnumerable, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

参数

expected: IEnumerable

应等于 actual的序列。

actual: IEnumerable

由所测试的代码生成的序列。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)

Source:: Assert.AreSequenceEqual.cs

测试两个序列是否包含使用指定顺序语义的相等元素，如果未指定序列，则引发异常。

public static void AreSequenceEqual(System.Collections.IEnumerable? expected, System.Collections.IEnumerable? actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual (expected As IEnumerable, actual As IEnumerable, order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

参数

expected: IEnumerable

应等于 actual的序列。

actual: IEnumerable

由所测试的代码生成的序列。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)

Source:: Assert.AreSequenceEqual.cs

使用指定的比较器测试两个序列是否包含相同顺序的相等元素，如果没有，则引发异常。

public static void AreSequenceEqual(System.Collections.IEnumerable? expected, System.Collections.IEnumerable? actual, System.Collections.IEqualityComparer? comparer, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * System.Collections.IEqualityComparer * string * string * string -> unit

Public Shared Sub AreSequenceEqual (expected As IEnumerable, actual As IEnumerable, comparer As IEqualityComparer, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

参数

expected: IEnumerable

应等于 actual的序列。

actual: IEnumerable

由所测试的代码生成的序列。

comparer: IEqualityComparer

比较元素时要使用的相等比较器，或使用 null 默认比较器。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)

Source:: Assert.AreSequenceEqual.cs

测试两个序列是否包含使用指定的比较器和顺序语义的相等元素，如果未指定序列，则引发异常。

public static void AreSequenceEqual(System.Collections.IEnumerable? expected, System.Collections.IEnumerable? actual, System.Collections.IEqualityComparer? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * System.Collections.IEqualityComparer * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual (expected As IEnumerable, actual As IEnumerable, comparer As IEqualityComparer, order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

参数

expected: IEnumerable

应等于 actual的序列。

actual: IEnumerable

由所测试的代码生成的序列。

comparer: IEqualityComparer

比较元素时要使用的相等比较器，或使用 null 默认比较器。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

测试两个跨度是否包含使用指定的比较器和顺序语义的相等元素，如果未指定范围，则引发异常。

public static void AreSequenceEqual<T>(Span<T> expected, Span<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : Span<'T> * Span<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As Span(Of T), actual As Span(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: Span<T>

预计范围等于 actual。

actual: Span<T>

由所测试的代码生成的范围。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

测试两个跨度是否包含使用指定的比较器和顺序语义的相等元素，如果未指定范围，则引发异常。

public static void AreSequenceEqual<T>(ReadOnlySpan<T> expected, ReadOnlySpan<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: ReadOnlySpan<T>

预计范围等于 actual。

actual: ReadOnlySpan<T>

由所测试的代码生成的范围。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

测试两个内存区域是否包含使用指定的比较器和顺序语义的相等元素，如果未指定，则引发异常。

public static void AreSequenceEqual<T>(ReadOnlyMemory<T> expected, ReadOnlyMemory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: ReadOnlyMemory<T>

应等于 actual的内存。

actual: ReadOnlyMemory<T>

受测代码生成的内存。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

测试两个内存区域是否包含使用指定的比较器和顺序语义的相等元素，如果未指定，则引发异常。

public static void AreSequenceEqual<T>(Memory<T> expected, Memory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : Memory<'T> * Memory<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As Memory(Of T), actual As Memory(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: Memory<T>

应等于 actual的内存。

actual: Memory<T>

受测代码生成的内存。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Source:: Assert.AreSequenceEqual.cs

测试两个序列是否包含使用指定的比较器和顺序语义的相等元素，如果未指定序列，则引发异常。

public static void AreSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : seq<'T> * seq<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As IEnumerable(Of T), actual As IEnumerable(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: IEnumerable<T>

应等于 actual的序列。

actual: IEnumerable<T>

由所测试的代码生成的序列。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)

使用指定的比较器测试两个跨度是否包含相同顺序的相等元素，如果没有，则引发异常。

public static void AreSequenceEqual<T>(Span<T> expected, Span<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : Span<'T> * Span<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As Span(Of T), actual As Span(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: Span<T>

预计范围等于 actual。

actual: Span<T>

由所测试的代码生成的范围。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)

测试两个跨度是否包含使用指定顺序语义的相等元素，如果未指定，则引发异常。

public static void AreSequenceEqual<T>(Span<T> expected, Span<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : Span<'T> * Span<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As Span(Of T), actual As Span(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: Span<T>

预计范围等于 actual。

actual: Span<T>

由所测试的代码生成的范围。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)

使用指定的比较器测试两个跨度是否包含相同顺序的相等元素，如果没有，则引发异常。

public static void AreSequenceEqual<T>(ReadOnlySpan<T> expected, ReadOnlySpan<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: ReadOnlySpan<T>

预计范围等于 actual。

actual: ReadOnlySpan<T>

由所测试的代码生成的范围。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)

使用指定的比较器测试两个内存区域是否包含相同顺序的相同元素，如果未指定，则引发异常。

public static void AreSequenceEqual<T>(ReadOnlyMemory<T> expected, ReadOnlyMemory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: ReadOnlyMemory<T>

应等于 actual的内存。

actual: ReadOnlyMemory<T>

受测代码生成的内存。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)

测试两个跨度是否包含使用指定顺序语义的相等元素，如果未指定，则引发异常。

public static void AreSequenceEqual<T>(ReadOnlySpan<T> expected, ReadOnlySpan<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: ReadOnlySpan<T>

预计范围等于 actual。

actual: ReadOnlySpan<T>

由所测试的代码生成的范围。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)

使用指定的比较器测试两个内存区域是否包含相同顺序的相同元素，如果未指定，则引发异常。

public static void AreSequenceEqual<T>(Memory<T> expected, Memory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : Memory<'T> * Memory<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As Memory(Of T), actual As Memory(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: Memory<T>

应等于 actual的内存。

actual: Memory<T>

受测代码生成的内存。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)

测试两个内存区域是否包含使用指定顺序语义的相等元素，如果未指定，则引发异常。

public static void AreSequenceEqual<T>(ReadOnlyMemory<T> expected, ReadOnlyMemory<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: ReadOnlyMemory<T>

应等于 actual的内存。

actual: ReadOnlyMemory<T>

受测代码生成的内存。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(Memory<T>, Memory<T>, String, String, String)

测试两个内存区域是否包含相同顺序的相等元素，如果没有，则会引发异常。

public static void AreSequenceEqual<T>(Memory<T> expected, Memory<T> actual, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : Memory<'T> * Memory<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As Memory(Of T), actual As Memory(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: Memory<T>

应等于 actual的内存。

actual: Memory<T>

受测代码生成的内存。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)

测试两个内存区域是否包含相同顺序的相等元素，如果没有，则会引发异常。

public static void AreSequenceEqual<T>(ReadOnlyMemory<T> expected, ReadOnlyMemory<T> actual, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: ReadOnlyMemory<T>

应等于 actual的内存。

actual: ReadOnlyMemory<T>

受测代码生成的内存。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)

测试两个跨度是否包含相同顺序的相等元素，如果没有，则会引发异常。

public static void AreSequenceEqual<T>(ReadOnlySpan<T> expected, ReadOnlySpan<T> actual, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: ReadOnlySpan<T>

预计范围等于 actual。

actual: ReadOnlySpan<T>

由所测试的代码生成的范围。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)

Source:: Assert.AreSequenceEqual.cs

测试两个序列是否包含相同顺序的相等元素，如果没有，则会引发异常。

public static void AreSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : seq<'T> * seq<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As IEnumerable(Of T), actual As IEnumerable(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: IEnumerable<T>

应等于 actual的序列。

actual: IEnumerable<T>

由所测试的代码生成的序列。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)

Source:: Assert.AreSequenceEqual.cs

测试两个序列是否包含使用指定顺序语义的相等元素，如果未指定序列，则引发异常。

public static void AreSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : seq<'T> * seq<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As IEnumerable(Of T), actual As IEnumerable(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: IEnumerable<T>

应等于 actual的序列。

actual: IEnumerable<T>

由所测试的代码生成的序列。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)

Source:: Assert.AreSequenceEqual.cs

使用指定的比较器测试两个序列是否包含相同顺序的相等元素，如果没有，则引发异常。

public static void AreSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : seq<'T> * seq<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As IEnumerable(Of T), actual As IEnumerable(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: IEnumerable<T>

应等于 actual的序列。

actual: IEnumerable<T>

由所测试的代码生成的序列。

comparer: IEqualityComparer<T>

比较元素时要使用的相等比较器，或使用 null 默认比较器。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)

测试两个内存区域是否包含使用指定顺序语义的相等元素，如果未指定，则引发异常。

public static void AreSequenceEqual<T>(Memory<T> expected, Memory<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : Memory<'T> * Memory<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As Memory(Of T), actual As Memory(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: Memory<T>

应等于 actual的内存。

actual: Memory<T>

受测代码生成的内存。

order: SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

AreSequenceEqual<T>(Span<T>, Span<T>, String, String, String)

测试两个跨度是否包含相同顺序的相等元素，如果没有，则会引发异常。

public static void AreSequenceEqual<T>(Span<T> expected, Span<T> actual, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreSequenceEqual : Span<'T> * Span<'T> * string * string * string -> unit

Public Shared Sub AreSequenceEqual(Of T) (expected As Span(Of T), actual As Span(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

类型参数

T

序列元素的类型。

参数

expected: Span<T>

预计范围等于 actual。

actual: Span<T>

由所测试的代码生成的范围。

message: String

序列不相等时要包含在异常中的消息。

expectedExpression: String

编译器通过调用方参数表达式给出的预期语法表达式。

actualExpression: String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

反馈

此页面是否有帮助？