Assert.AreSequenceEqual Metodo

Definizione

Spazio dei nomi:: Microsoft.VisualStudio.TestTools.UnitTesting

Assembly:: MSTest.TestFramework.dll

Pacchetto:: MSTest.TestFramework v4.4.0

Pacchetto:: MSTest.TestFramework v4.3.0

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Overload

Nome	Descrizione
AreSequenceEqual(IEnumerable, IEnumerable, String, String, String)	Verifica se due sequenze contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.
AreSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)	Verifica se due sequenze contengono elementi uguali usando la semantica dell'ordine specificata e genera un'eccezione in caso contrario.
AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)	Verifica se due sequenze contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.
AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)	Verifica se due sequenze contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Verifica se due intervalli contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Verifica se due intervalli contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Verifica se due aree di memoria contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Verifica se due aree di memoria contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Verifica se due sequenze contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)	Verifica se due intervalli contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)	Verifica se due intervalli contengono elementi uguali usando la semantica dell'ordine specificato e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)	Verifica se due intervalli contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)	Verifica se due aree di memoria contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)	Verifica se due intervalli contengono elementi uguali usando la semantica dell'ordine specificato e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)	Verifica se due aree di memoria contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)	Verifica se due aree di memoria contengono elementi uguali usando la semantica dell'ordine specificata e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(Memory<T>, Memory<T>, String, String, String)	Verifica se due aree di memoria contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)	Verifica se due aree di memoria contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)	Verifica se due intervalli contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)	Verifica se due sequenze contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)	Verifica se due sequenze contengono elementi uguali usando la semantica dell'ordine specificata e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)	Verifica se due sequenze contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)	Verifica se due aree di memoria contengono elementi uguali usando la semantica dell'ordine specificata e genera un'eccezione in caso contrario.
AreSequenceEqual<T>(Span<T>, Span<T>, String, String, String)	Verifica se due intervalli contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.

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

Origine:: Assert.AreSequenceEqual.cs

Verifica se due sequenze contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.

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 = "")

Parametri

expected: IEnumerable

La sequenza dovrebbe essere uguale a actual.

actual: IEnumerable

Sequenza prodotta dal codice sottoposto a test.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Origine:: Assert.AreSequenceEqual.cs

Verifica se due sequenze contengono elementi uguali usando la semantica dell'ordine specificata e genera un'eccezione in caso contrario.

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 = "")

Parametri

expected: IEnumerable

La sequenza dovrebbe essere uguale a actual.

actual: IEnumerable

Sequenza prodotta dal codice sottoposto a test.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Origine:: Assert.AreSequenceEqual.cs

Verifica se due sequenze contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.

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 = "")

Parametri

expected: IEnumerable

La sequenza dovrebbe essere uguale a actual.

actual: IEnumerable

Sequenza prodotta dal codice sottoposto a test.

comparer: IEqualityComparer

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Origine:: Assert.AreSequenceEqual.cs

Verifica se due sequenze contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.

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 = "")

Parametri

expected: IEnumerable

La sequenza dovrebbe essere uguale a actual.

actual: IEnumerable

Sequenza prodotta dal codice sottoposto a test.

comparer: IEqualityComparer

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due intervalli contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: Span<T>

L'intervallo previsto sarà uguale a actual.

actual: Span<T>

Intervallo prodotto dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due intervalli contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: ReadOnlySpan<T>

L'intervallo previsto sarà uguale a actual.

actual: ReadOnlySpan<T>

Intervallo prodotto dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due aree di memoria contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: ReadOnlyMemory<T>

La memoria prevista sarà uguale a actual.

actual: ReadOnlyMemory<T>

Memoria prodotta dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due aree di memoria contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: Memory<T>

La memoria prevista sarà uguale a actual.

actual: Memory<T>

Memoria prodotta dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Origine:: Assert.AreSequenceEqual.cs

Verifica se due sequenze contengono elementi uguali usando l'operatore di confronto e la semantica dell'ordine specificati e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: IEnumerable<T>

La sequenza dovrebbe essere uguale a actual.

actual: IEnumerable<T>

Sequenza prodotta dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due intervalli contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: Span<T>

L'intervallo previsto sarà uguale a actual.

actual: Span<T>

Intervallo prodotto dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due intervalli contengono elementi uguali usando la semantica dell'ordine specificato e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: Span<T>

L'intervallo previsto sarà uguale a actual.

actual: Span<T>

Intervallo prodotto dal codice sottoposto a test.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due intervalli contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: ReadOnlySpan<T>

L'intervallo previsto sarà uguale a actual.

actual: ReadOnlySpan<T>

Intervallo prodotto dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due aree di memoria contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: ReadOnlyMemory<T>

La memoria prevista sarà uguale a actual.

actual: ReadOnlyMemory<T>

Memoria prodotta dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due intervalli contengono elementi uguali usando la semantica dell'ordine specificato e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: ReadOnlySpan<T>

L'intervallo previsto sarà uguale a actual.

actual: ReadOnlySpan<T>

Intervallo prodotto dal codice sottoposto a test.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due aree di memoria contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: Memory<T>

La memoria prevista sarà uguale a actual.

actual: Memory<T>

Memoria prodotta dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due aree di memoria contengono elementi uguali usando la semantica dell'ordine specificata e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: ReadOnlyMemory<T>

La memoria prevista sarà uguale a actual.

actual: ReadOnlyMemory<T>

Memoria prodotta dal codice sottoposto a test.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due aree di memoria contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: Memory<T>

La memoria prevista sarà uguale a actual.

actual: Memory<T>

Memoria prodotta dal codice sottoposto a test.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due aree di memoria contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: ReadOnlyMemory<T>

La memoria prevista sarà uguale a actual.

actual: ReadOnlyMemory<T>

Memoria prodotta dal codice sottoposto a test.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due intervalli contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: ReadOnlySpan<T>

L'intervallo previsto sarà uguale a actual.

actual: ReadOnlySpan<T>

Intervallo prodotto dal codice sottoposto a test.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Origine:: Assert.AreSequenceEqual.cs

Verifica se due sequenze contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: IEnumerable<T>

La sequenza dovrebbe essere uguale a actual.

actual: IEnumerable<T>

Sequenza prodotta dal codice sottoposto a test.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Origine:: Assert.AreSequenceEqual.cs

Verifica se due sequenze contengono elementi uguali usando la semantica dell'ordine specificata e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: IEnumerable<T>

La sequenza dovrebbe essere uguale a actual.

actual: IEnumerable<T>

Sequenza prodotta dal codice sottoposto a test.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Origine:: Assert.AreSequenceEqual.cs

Verifica se due sequenze contengono elementi uguali nello stesso ordine usando l'operatore di confronto specificato e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: IEnumerable<T>

La sequenza dovrebbe essere uguale a actual.

actual: IEnumerable<T>

Sequenza prodotta dal codice sottoposto a test.

comparer: IEqualityComparer<T>

Operatore di confronto di uguaglianza da usare per confrontare gli elementi o null per usare l'operatore di confronto predefinito.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due aree di memoria contengono elementi uguali usando la semantica dell'ordine specificata e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: Memory<T>

La memoria prevista sarà uguale a actual.

actual: Memory<T>

Memoria prodotta dal codice sottoposto a test.

order: SequenceOrder

Specifica se gli elementi devono essere visualizzati nello stesso ordine o in qualsiasi ordine.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

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

Verifica se due intervalli contengono elementi uguali nello stesso ordine e genera un'eccezione in caso contrario.

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 = "")

Parametri di tipo

T

Tipo di elementi di sequenza.

Parametri

expected: Span<T>

L'intervallo previsto sarà uguale a actual.

actual: Span<T>

Intervallo prodotto dal codice sottoposto a test.

message: String

Messaggio da includere nell'eccezione quando le sequenze non sono uguali.

expectedExpression: String

Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante.

actualExpression: String

Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante.

Si applica a

Commenti e suggerimenti

Questa pagina è stata utile?