Assert.AreSequenceEqual 方法

定義

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

組件:: MSTest.TestFramework.dll

套件:: MSTest.TestFramework v4.4.0

套件:: MSTest.TestFramework v4.3.0

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

多載

名稱	Description
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)

來源:: 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)

來源:: 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)

來源:: 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)

來源:: 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)

來源:: 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)

來源:: 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)

來源:: 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)

來源:: 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

實際的語法表達式，由編譯器透過呼叫者參數表達式給出。

適用於

意見反應

此頁面對您有幫助嗎？