Assert 类

定义

命名空间:
Microsoft.VisualStudio.TestTools.UnitTesting
程序集:
Microsoft.VisualStudio.TestPlatform.TestFramework.dll
程序集:
MSTest.TestFramework.dll
程序集:
Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll
包:
MSTest.TestFramework v1.1.18
包:
MSTest.TestFramework v1.2.1
包:
MSTest.TestFramework v1.3.2
包:
MSTest.TestFramework v1.4.0
包:
MSTest.TestFramework v2.0.0
包:
MSTest.TestFramework v2.1.2
包:
MSTest.TestFramework v2.2.10
包:
MSTest.TestFramework v3.0.4
包:
MSTest.TestFramework v3.1.1
包:
MSTest.TestFramework v3.10.5
包:
MSTest.TestFramework v3.11.0
包:
MSTest.TestFramework v3.2.2
包:
MSTest.TestFramework v3.3.1
包:
MSTest.TestFramework v3.4.3
包:
MSTest.TestFramework v3.5.2
包:
MSTest.TestFramework v3.6.4
包:
MSTest.TestFramework v3.7.3
包:
MSTest.TestFramework v3.8.3
包:
MSTest.TestFramework v3.9.3
包:
MSTest.TestFramework v4.0.2
包:
MSTest.TestFramework v4.1.0
包:
MSTest.TestFramework v4.2.3
包:
MSTest.TestFramework v4.3.0
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs
Source:
Assert.cs

用于在单元测试中测试各种条件的帮助程序类的集合。 如果未满足要测试的条件，则会引发异常。

public class Assert
public sealed class Assert
[System.Runtime.CompilerServices.Nullable(0)]
public sealed class Assert
[System.Runtime.CompilerServices.Nullable(0)]
[System.Diagnostics.StackTraceHidden]
public sealed class Assert
public static class Assert
type Assert = class
[<System.Runtime.CompilerServices.Nullable(0)>]
type Assert = class
[<System.Runtime.CompilerServices.Nullable(0)>]
[<System.Diagnostics.StackTraceHidden>]
type Assert = class
Public Class Assert
Public NotInheritable Class Assert
继承
Object
Assert
属性
NullableAttribute StackTraceHiddenAttribute

构造函数

名称 说明
Assert()

用于在单元测试中测试各种条件的帮助程序类的集合。 如果未满足要测试的条件，则会引发异常。

属性

名称 说明
That

获取 Assert 功能的单一实例。

方法

名称 说明
AddValueFormatter(Func<Func<Object,String>,Func<Object,String>>)

注册责任链值格式化程序工厂。 工厂在链中接收 next 格式化程序并返回新的格式化程序;返回的格式化程序应为它处理的值生成字符串，或者为它未处理的值生成一个字符串 next 。 注册的范围限定为当前异步流，并在释放返回 IDisposable 时删除。
AddValueFormatter<T>(Func<T,String>)

注册一个自定义格式化程序，用于控制如何在结构化断言失败消息中呈现值 T 。 注册的范围限定为当前异步流（由 AsyncLocal<T>该流提供支持），并在释放返回 IDisposable 时删除。
AreAllDistinct(IEnumerable, IEqualityComparer, String, String)

使用提供的 comparer 集合测试指定集合中的所有项是否不同（无两个元素相等），如果集合中的任何两个元素相等，则会引发异常。
AreAllDistinct(IEnumerable, String, String)

测试指定集合中的所有项是否不同（无两个元素相等），如果集合中的任何两个元素相等，则会引发异常。
AreAllDistinct<T>(IEnumerable<T>, IEqualityComparer<T>, String, String)

使用提供的 comparer 集合测试指定集合中的所有项是否不同（无两个元素相等），如果集合中的任何两个元素相等，则会引发异常。
AreAllDistinct<T>(IEnumerable<T>, String, String)

测试指定集合中的所有项是否不同（无两个元素相等），如果集合中的任何两个元素相等，则会引发异常。
AreAllNotNull(IEnumerable, String, String)

测试指定集合中的所有项是否为非 null，如果任何元素为 null，则引发异常。
AreAllNotNull<T>(IEnumerable<T>, String, String)

测试指定集合中的所有项是否为非 null，如果任何元素为 null，则引发异常。
AreAllOfType(Type, IEnumerable, String, String, String)

测试指定集合中的所有元素是预期类型的实例（或派生自），如果预期类型不在一个或多个元素的继承层次结构中，或者任何元素为 null，则引发异常。
AreAllOfType<TExpected>(IEnumerable, String, String)

测试指定集合中的所有元素是预期类型的实例（或派生自），如果预期类型不在一个或多个元素的继承层次结构中，或者任何元素为 null，则引发异常。
AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

测试指定的小数是否相等，如果它们不相等，则会引发异常。
AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

测试指定的小数是否相等，如果它们不相等，则会引发异常。
AreEqual(Decimal, Decimal, Decimal, String, Object[])

测试指定的小数是否相等，如果它们不相等，则会引发异常。
AreEqual(Decimal, Decimal, Decimal, String, String, String)

测试指定的小数是否相等，如果它们不相等，则会引发异常。
AreEqual(Decimal, Decimal, Decimal, String)

测试指定的小数是否相等，如果它们不相等，则会引发异常。
AreEqual(Decimal, Decimal, Decimal)

测试指定的小数是否相等，如果它们不相等，则会引发异常。
AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

测试指定的双精度值是否相等，如果它们不相等，则会引发异常。
AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

测试指定的双精度值是否相等，如果它们不相等，则会引发异常。
AreEqual(Double, Double, Double, String, Object[])

测试指定的双精度值是否相等，如果它们不相等，则会引发异常。
AreEqual(Double, Double, Double, String, String, String)

测试指定的双精度值是否相等，如果它们不相等，则会引发异常。
AreEqual(Double, Double, Double, String)

测试指定的双精度值是否相等，如果它们不相等，则会引发异常。
AreEqual(Double, Double, Double)

测试指定的双精度值是否相等，如果它们不相等，则会引发异常。
AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

测试指定的长长度是否相等，如果它们不相等，则会引发异常。
AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

测试指定的长长度是否相等，如果它们不相等，则会引发异常。
AreEqual(Int64, Int64, Int64, String, Object[])

测试指定的长长度是否相等，如果它们不相等，则会引发异常。
AreEqual(Int64, Int64, Int64, String, String, String)

测试指定的长长度是否相等，如果它们不相等，则会引发异常。
AreEqual(Int64, Int64, Int64, String)

测试指定的长长度是否相等，如果它们不相等，则会引发异常。
AreEqual(Int64, Int64, Int64)

测试指定的长长度是否相等，如果它们不相等，则会引发异常。
AreEqual(Object, Object, String, Object[])

测试指定的对象是否相等，如果两个对象不相等，则会引发异常。 即使逻辑值相等，不同的数值类型也被视为不相等。 42L 不等于 42。
AreEqual(Object, Object, String)

测试指定的对象是否相等，如果两个对象不相等，则会引发异常。 即使逻辑值相等，不同的数值类型也被视为不相等。 42L 不等于 42。
AreEqual(Object, Object)

测试指定的对象是否相等，如果两个对象不相等，则会引发异常。 即使逻辑值相等，不同的数值类型也被视为不相等。 42L 不等于 42。
AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

测试指定的浮点是否相等，如果它们不相等，则会引发异常。
AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

测试指定的浮点是否相等，如果它们不相等，则会引发异常。
AreEqual(Single, Single, Single, String, Object[])

测试指定的浮点是否相等，如果它们不相等，则会引发异常。
AreEqual(Single, Single, Single, String, String, String)

测试指定的浮点是否相等，如果它们不相等，则会引发异常。
AreEqual(Single, Single, Single, String)

测试指定的浮点是否相等，如果它们不相等，则会引发异常。
AreEqual(Single, Single, Single)

测试指定的浮点是否相等，如果它们不相等，则会引发异常。
AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

测试指定的字符串是否相等，并在它们不相等时引发异常。 固定区域性用于比较。
AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

测试指定的字符串是否相等，并在它们不相等时引发异常。 固定区域性用于比较。
AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

测试指定的字符串是否相等，并在它们不相等时引发异常。
AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

测试指定的字符串是否相等，并在它们不相等时引发异常。
AreEqual(String, String, Boolean, CultureInfo, String, Object[])

测试指定的字符串是否相等，并在它们不相等时引发异常。
AreEqual(String, String, Boolean, CultureInfo, String, String, String)

测试指定的字符串是否相等，并在它们不相等时引发异常。
AreEqual(String, String, Boolean, CultureInfo, String)

测试指定的字符串是否相等，并在它们不相等时引发异常。
AreEqual(String, String, Boolean, CultureInfo)

测试指定的字符串是否相等，并在它们不相等时引发异常。
AreEqual(String, String, Boolean, String, Object[])

测试指定的字符串是否相等，并在它们不相等时引发异常。 固定区域性用于比较。
AreEqual(String, String, Boolean, String, String, String)

测试指定的字符串是否相等，并在它们不相等时引发异常。 固定区域性用于比较。
AreEqual(String, String, Boolean, String)

测试指定的字符串是否相等，并在它们不相等时引发异常。 固定区域性用于比较。
AreEqual(String, String, Boolean)

测试指定的字符串是否相等，并在它们不相等时引发异常。 固定区域性用于比较。
AreEqual<T>(IEquatable<T>, IEquatable<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(IEquatable<T>, IEquatable<T>, String, Object[])

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(IEquatable<T>, IEquatable<T>, String)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(IEquatable<T>, IEquatable<T>)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用提供 comparer 的参数计算相等性。
AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用提供 comparer 的参数计算相等性。
AreEqual<T>(T, T, IEqualityComparer<T>, String, Object[])

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用提供 comparer 的参数计算相等性。
AreEqual<T>(T, T, IEqualityComparer<T>, String, String, String)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用提供 comparer 的参数计算相等性。
AreEqual<T>(T, T, IEqualityComparer<T>, String)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用提供 comparer 的参数计算相等性。
AreEqual<T>(T, T, IEqualityComparer<T>)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(T, T, String, Object[])

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(T, T, String, String, String)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(T, T, String)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEqual<T>(T, T)

测试指定的值是否相等，如果两个值不相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreEquivalent<T>(T, T, Boolean, String, String, String)

测试两个对象图在结构上是否等效（深度相等），如果它们不是，则会引发异常。
AreEquivalent<T>(T, T, String, String, String)

测试两个对象图在结构上是否等效（深度相等），如果它们不是，则会引发异常。
AreNotEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler, String, String)

测试指定的十进制值是否不相等，并在它们相等时引发异常。
AreNotEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler)

测试指定的十进制值是否不相等，并在它们相等时引发异常。
AreNotEqual(Decimal, Decimal, Decimal, String, Object[])

测试指定的十进制值是否不相等，并在它们相等时引发异常。
AreNotEqual(Decimal, Decimal, Decimal, String, String, String)

测试指定的十进制值是否不相等，并在它们相等时引发异常。
AreNotEqual(Decimal, Decimal, Decimal, String)

测试指定的十进制值是否不相等，并在它们相等时引发异常。
AreNotEqual(Decimal, Decimal, Decimal)

测试指定的十进制值是否不相等，并在它们相等时引发异常。
AreNotEqual(Double, Double, Double, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler, String, String)

测试指定的双精度值是否不相等，并在它们相等时引发异常。
AreNotEqual(Double, Double, Double, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler)

测试指定的双精度值是否不相等，并在它们相等时引发异常。
AreNotEqual(Double, Double, Double, String, Object[])

测试指定的双精度值是否不相等，并在它们相等时引发异常。
AreNotEqual(Double, Double, Double, String, String, String)

测试指定的双精度值是否不相等，并在它们相等时引发异常。
AreNotEqual(Double, Double, Double, String)

测试指定的双精度值是否不相等，并在它们相等时引发异常。
AreNotEqual(Double, Double, Double)

测试指定的双精度值是否不相等，并在它们相等时引发异常。
AreNotEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler, String, String)

测试指定的长长度是否不相等，并在它们相等时引发异常。
AreNotEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler)

测试指定的长长度是否不相等，并在它们相等时引发异常。
AreNotEqual(Int64, Int64, Int64, String, Object[])

测试指定的长长度是否不相等，并在它们相等时引发异常。
AreNotEqual(Int64, Int64, Int64, String, String, String)

测试指定的长长度是否不相等，并在它们相等时引发异常。
AreNotEqual(Int64, Int64, Int64, String)

测试指定的长长度是否不相等，并在它们相等时引发异常。
AreNotEqual(Int64, Int64, Int64)

测试指定的长长度是否不相等，并在它们相等时引发异常。
AreNotEqual(Object, Object, String, Object[])

测试指定的对象是否不相等，如果两个对象相等，则会引发异常。 即使逻辑值相等，不同的数值类型也被视为不相等。 42L 不等于 42。
AreNotEqual(Object, Object, String)

测试指定的对象是否不相等，如果两个对象相等，则会引发异常。 即使逻辑值相等，不同的数值类型也被视为不相等。 42L 不等于 42。
AreNotEqual(Object, Object)

测试指定的对象是否不相等，如果两个对象相等，则会引发异常。 即使逻辑值相等，不同的数值类型也被视为不相等。 42L 不等于 42。
AreNotEqual(Single, Single, Single, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler, String, String)

测试指定的浮点是否不相等，并在它们相等时引发异常。
AreNotEqual(Single, Single, Single, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler)

测试指定的浮点是否不相等，并在它们相等时引发异常。
AreNotEqual(Single, Single, Single, String, Object[])

测试指定的浮点是否不相等，并在它们相等时引发异常。
AreNotEqual(Single, Single, Single, String, String, String)

测试指定的浮点是否不相等，并在它们相等时引发异常。
AreNotEqual(Single, Single, Single, String)

测试指定的浮点是否不相等，并在它们相等时引发异常。
AreNotEqual(Single, Single, Single)

测试指定的浮点是否不相等，并在它们相等时引发异常。
AreNotEqual(String, String, Boolean, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler, String, String)

测试指定的字符串是否不相等，并在它们相等时引发异常。 固定区域性用于比较。
AreNotEqual(String, String, Boolean, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler)

测试指定的字符串是否不相等，并在它们相等时引发异常。 固定区域性用于比较。
AreNotEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler, String, String)

测试指定的字符串是否不相等，并在它们相等时引发异常。
AreNotEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreNotEqualInterpolatedStringHandler)

测试指定的字符串是否不相等，并在它们相等时引发异常。
AreNotEqual(String, String, Boolean, CultureInfo, String, Object[])

测试指定的字符串是否不相等，并在它们相等时引发异常。
AreNotEqual(String, String, Boolean, CultureInfo, String, String, String)

测试指定的字符串是否不相等，并在它们相等时引发异常。
AreNotEqual(String, String, Boolean, CultureInfo, String)

测试指定的字符串是否不相等，并在它们相等时引发异常。
AreNotEqual(String, String, Boolean, CultureInfo)

测试指定的字符串是否不相等，并在它们相等时引发异常。
AreNotEqual(String, String, Boolean, String, Object[])

测试指定的字符串是否不相等，并在它们相等时引发异常。 固定区域性用于比较。
AreNotEqual(String, String, Boolean, String, String, String)

测试指定的字符串是否不相等，并在它们相等时引发异常。 固定区域性用于比较。
AreNotEqual(String, String, Boolean, String)

测试指定的字符串是否不相等，并在它们相等时引发异常。 固定区域性用于比较。
AreNotEqual(String, String, Boolean)

测试指定的字符串是否不相等，并在它们相等时引发异常。 固定区域性用于比较。
AreNotEqual<T>(T, T, Assert.AssertAreNotEqualInterpolatedStringHandler<T>, String, String)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreNotEqual<T>(T, T, Assert.AssertAreNotEqualInterpolatedStringHandler<T>)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreNotEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreNotEqualInterpolatedStringHandler<T>, String, String)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreNotEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreNotEqualInterpolatedStringHandler<T>)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreNotEqual<T>(T, T, IEqualityComparer<T>, String, Object[])

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用提供 comparer 的参数计算相等性。
AreNotEqual<T>(T, T, IEqualityComparer<T>, String, String, String)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用提供 comparer 的参数计算相等性。
AreNotEqual<T>(T, T, IEqualityComparer<T>, String)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用提供 comparer 的参数计算相等性。
AreNotEqual<T>(T, T, IEqualityComparer<T>)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用提供 comparer 的参数计算相等性。
AreNotEqual<T>(T, T, String, Object[])

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreNotEqual<T>(T, T, String, String, String)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreNotEqual<T>(T, T, String)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreNotEqual<T>(T, T)

测试指定的值是否不相等，如果两个值相等，则会引发异常。 使用默认值 EqualityComparer<T>计算相等性。
AreNotEquivalent<T>(T, T, Boolean, String, String, String)

测试两个对象图在结构上是否不相等，并引发异常（如果存在）。
AreNotEquivalent<T>(T, T, String, String, String)

测试两个对象图在结构上是否不相等，并引发异常（如果存在）。
AreNotSame(Object, Object, String, Object[])

测试指定的对象是否引用不同的对象，如果两个输入引用同一对象，则会引发异常。
AreNotSame(Object, Object, String)

测试指定的对象是否引用不同的对象，如果两个输入引用同一对象，则会引发异常。
AreNotSame(Object, Object)

测试指定的对象是否引用不同的对象，如果两个输入引用同一对象，则会引发异常。
AreNotSame<T>(T, T, Assert.AssertAreNotSameInterpolatedStringHandler<T>, String, String)

测试指定的对象是否引用不同的对象，如果两个输入引用同一对象，则会引发异常。
AreNotSame<T>(T, T, Assert.AssertAreNotSameInterpolatedStringHandler<T>)

测试指定的对象是否引用不同的对象，如果两个输入引用同一对象，则会引发异常。
AreNotSame<T>(T, T, String, Object[])

测试指定的对象是否引用不同的对象，如果两个输入引用同一对象，则会引发异常。
AreNotSame<T>(T, T, String, String, String)

测试指定的对象是否引用不同的对象，如果两个输入引用同一对象，则会引发异常。
AreNotSame<T>(T, T, String)

测试指定的对象是否引用不同的对象，如果两个输入引用同一对象，则会引发异常。
AreNotSame<T>(T, T)

测试指定的对象是否引用不同的对象，如果两个输入引用同一对象，则会引发异常。
AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)

测试两个序列是否使用指定的比较器和顺序语义不同，如果两个序列不同，则引发异常。
AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)

使用指定的比较器测试两个序列是否以相同顺序不同，如果两个序列不同，则引发异常。
AreNotSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)

测试两个序列是否使用指定的顺序语义不同，如果未指定序列，则会引发异常。
AreNotSequenceEqual(IEnumerable, IEnumerable, String, String, String)

测试两个序列是否以相同顺序不同，如果两个序列不同，则引发异常。
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

测试两个序列是否使用指定的比较器和顺序语义不同，如果两个序列不同，则引发异常。
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)

使用指定的比较器测试两个序列是否以相同顺序不同，如果两个序列不同，则引发异常。
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)

测试两个序列是否使用指定的顺序语义不同，如果未指定序列，则会引发异常。
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)

测试两个序列是否以相同顺序不同，如果两个序列不同，则引发异常。
AreSame(Object, Object, String, Object[])

测试指定的对象是否都引用同一对象，如果两个输入不引用同一对象，则会引发异常。
AreSame(Object, Object, String)

测试指定的对象是否都引用同一对象，如果两个输入不引用同一对象，则会引发异常。
AreSame(Object, Object)

测试指定的对象是否都引用同一对象，如果两个输入不引用同一对象，则会引发异常。
AreSame<T>(T, T, Assert.AssertAreSameInterpolatedStringHandler<T>, String, String)

测试指定的对象是否都引用同一对象，如果两个输入不引用同一对象，则会引发异常。
AreSame<T>(T, T, Assert.AssertAreSameInterpolatedStringHandler<T>)

测试指定的对象是否都引用同一对象，如果两个输入不引用同一对象，则会引发异常。
AreSame<T>(T, T, String, Object[])

测试指定的对象是否都引用同一对象，如果两个输入不引用同一对象，则会引发异常。
AreSame<T>(T, T, String, String, String)

测试指定的对象是否都引用同一对象，如果两个输入不引用同一对象，则会引发异常。
AreSame<T>(T, T, String)

测试指定的对象是否都引用同一对象，如果两个输入不引用同一对象，则会引发异常。
AreSame<T>(T, T)

测试指定的对象是否都引用同一对象，如果两个输入不引用同一对象，则会引发异常。
AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)

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

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

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

测试两个序列是否包含相同顺序的相等元素，如果没有，则会引发异常。
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

测试两个序列是否包含使用指定的比较器和顺序语义的相等元素，如果未指定序列，则引发异常。
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)

使用指定的比较器测试两个序列是否包含相同顺序的相等元素，如果没有，则引发异常。
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)

测试两个序列是否包含使用指定顺序语义的相等元素，如果未指定序列，则引发异常。
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)

测试两个序列是否包含相同顺序的相等元素，如果没有，则会引发异常。
Contains(Func<Object,Boolean>, IEnumerable, String, String, String)

测试指定的集合是否包含给定元素。
Contains(Func<Object,Boolean>, IEnumerable, String)

测试指定的集合是否包含给定元素。
Contains(Func<Object,Boolean>, IEnumerable)

测试指定的集合是否包含给定元素。
Contains(Object, IEnumerable, IEqualityComparer, String, String, String)

测试指定的集合是否包含给定元素。
Contains(Object, IEnumerable, IEqualityComparer, String)

测试指定的集合是否包含给定元素。
Contains(Object, IEnumerable, IEqualityComparer)

测试指定的集合是否包含给定元素。
Contains(Object, IEnumerable, String, String, String)

测试指定的集合是否包含给定元素。
Contains(Object, IEnumerable, String)

测试指定的集合是否包含给定元素。
Contains(Object, IEnumerable)

测试指定的非泛型集合是否包含给定元素。
Contains(String, String, String, Object[])

测试指定的字符串是否包含指定的子字符串，并在测试字符串中未发生子字符串时引发异常。
Contains(String, String, String, String, String)

测试指定的字符串是否包含指定的子字符串，并在测试字符串中未发生子字符串时引发异常。
Contains(String, String, String)

测试指定的字符串是否包含指定的子字符串，并在测试字符串中未发生子字符串时引发异常。
Contains(String, String, StringComparison, String, Object[])

测试指定的字符串是否包含指定的子字符串，并在测试字符串中未发生子字符串时引发异常。
Contains(String, String, StringComparison, String, String, String)

测试指定的字符串是否包含指定的子字符串，并在测试字符串中未发生子字符串时引发异常。
Contains(String, String, StringComparison, String)

测试指定的字符串是否包含指定的子字符串，并在测试字符串中未发生子字符串时引发异常。
Contains(String, String, StringComparison)

测试指定的字符串是否包含指定的子字符串，并在测试字符串中未发生子字符串时引发异常。
Contains(String, String)

测试指定的字符串是否包含指定的子字符串，并在测试字符串中未发生子字符串时引发异常。
Contains<T>(Func<T,Boolean>, IEnumerable<T>, String, Object[])

测试指定的集合是否包含给定元素。
Contains<T>(Func<T,Boolean>, IEnumerable<T>, String, String, String)

测试指定的集合是否包含给定元素。
Contains<T>(Func<T,Boolean>, IEnumerable<T>, String)

测试指定的集合是否包含给定元素。
Contains<T>(Func<T,Boolean>, IEnumerable<T>)

测试指定的集合是否包含给定元素。
Contains<T>(IEnumerable<T>, Func<T,Boolean>, String)

测试指定的集合是否包含给定元素。
Contains<T>(T, IEnumerable<T>, IEqualityComparer<T>, String, Object[])

测试指定的集合是否包含给定元素。
Contains<T>(T, IEnumerable<T>, IEqualityComparer<T>, String, String, String)

测试指定的集合是否包含给定元素。
Contains<T>(T, IEnumerable<T>, IEqualityComparer<T>, String)

测试指定的集合是否包含给定元素。
Contains<T>(T, IEnumerable<T>, IEqualityComparer<T>)

测试指定的集合是否包含给定元素。
Contains<T>(T, IEnumerable<T>, String, Object[])

测试指定的集合是否包含给定元素。
Contains<T>(T, IEnumerable<T>, String, String, String)

测试指定的集合是否包含给定元素。
Contains<T>(T, IEnumerable<T>, String)

测试指定的集合是否包含给定元素。
Contains<T>(T, IEnumerable<T>)

测试指定的集合是否包含给定元素。
ContainsAll(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)

测试是否 collection 包含（具有多重性）的每个元素 expected ，并在发生任何元素时引发异常（如果任何元素的 expected 发生次数超过在内 collection）。
ContainsAll(IEnumerable, IEnumerable, String, String, String)

测试是否 collection 包含（具有多重性）的每个元素 expected ，并在发生任何元素时引发异常（如果任何元素的 expected 发生次数超过在内 collection）。
ContainsAll<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)

测试是否 collection 包含（具有多重性）的每个元素 expected ，并在发生任何元素时引发异常（如果任何元素的 expected 发生次数超过在内 collection）。
ContainsAll<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)

测试是否 collection 包含（具有多重性）的每个元素 expected ，并在发生任何元素时引发异常（如果任何元素的 expected 发生次数超过在内 collection）。
ContainsSingle(Func<Object,Boolean>, IEnumerable, String, String, String)

测试指定的集合是否正好包含一个与给定谓词匹配的元素。
ContainsSingle(IEnumerable, String, String)

测试指定的集合是否只包含一个元素。
ContainsSingle<T>(Func<T,Boolean>, IEnumerable<T>, String, String, String)

测试指定的集合是否正好包含一个与给定谓词匹配的元素。
ContainsSingle<T>(Func<T,Boolean>, IEnumerable<T>, String)

测试指定的集合是否正好包含一个与给定谓词匹配的元素。
ContainsSingle<T>(IEnumerable<T>, Assert.AssertSingleInterpolatedStringHandler<T>, String)

测试指定的集合是否只包含一个元素。
ContainsSingle<T>(IEnumerable<T>, Assert.AssertSingleInterpolatedStringHandler<T>)

测试指定的集合是否只包含一个元素。
ContainsSingle<T>(IEnumerable<T>, String, Object[])

测试指定的集合是否只包含一个元素。
ContainsSingle<T>(IEnumerable<T>, String, String)

测试指定的集合是否只包含一个元素。
ContainsSingle<T>(IEnumerable<T>, String)

测试指定的集合是否只包含一个元素。
ContainsSingle<T>(IEnumerable<T>)

测试指定的集合是否只包含一个元素。
DoesNotContain(Func<Object,Boolean>, IEnumerable, String, String, String)

测试指定的集合是否不包含指定的项。
DoesNotContain(Func<Object,Boolean>, IEnumerable, String)

测试指定的集合是否不包含指定的项。
DoesNotContain(Func<Object,Boolean>, IEnumerable)

测试指定的集合是否不包含指定的项。
DoesNotContain(Object, IEnumerable, IEqualityComparer, String, String, String)

测试指定的集合是否不包含指定的项。
DoesNotContain(Object, IEnumerable, IEqualityComparer, String)

使用自定义相等比较器测试指定的非泛型集合是否不包含指定项。
DoesNotContain(Object, IEnumerable, IEqualityComparer)

测试指定的集合是否不包含指定的项。
DoesNotContain(Object, IEnumerable, String, String, String)

测试指定的集合是否不包含指定的项。
DoesNotContain(Object, IEnumerable, String)

测试指定的非泛型集合是否不包含指定的项。
DoesNotContain(Object, IEnumerable)

测试指定的非泛型集合是否不包含指定的项。
DoesNotContain(String, String, String, Object[])

测试指定的字符串是否不包含指定的子字符串，并在测试字符串中发生子字符串时引发异常。
DoesNotContain(String, String, String, String, String)

测试指定的字符串是否不包含指定的子字符串，并在测试字符串中发生子字符串时引发异常。
DoesNotContain(String, String, String)

测试指定的字符串是否不包含指定的子字符串，并在测试字符串中发生子字符串时引发异常。
DoesNotContain(String, String, StringComparison, String, Object[])

测试指定的字符串是否不包含指定的子字符串，并在测试字符串中发生子字符串时引发异常。
DoesNotContain(String, String, StringComparison, String, String, String)

测试指定的字符串是否不包含指定的子字符串，并在测试字符串中发生子字符串时引发异常。
DoesNotContain(String, String, StringComparison, String)

测试指定的字符串是否不包含指定的子字符串，并在测试字符串中发生子字符串时引发异常。
DoesNotContain(String, String, StringComparison)

测试指定的字符串是否不包含指定的子字符串，并在测试字符串中发生子字符串时引发异常。
DoesNotContain(String, String)

测试指定的字符串是否不包含指定的子字符串，并在测试字符串中发生子字符串时引发异常。
DoesNotContain<T>(Func<T,Boolean>, IEnumerable<T>, String, Object[])

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(Func<T,Boolean>, IEnumerable<T>, String, String, String)

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(Func<T,Boolean>, IEnumerable<T>, String)

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(Func<T,Boolean>, IEnumerable<T>)

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(T, IEnumerable<T>, IEqualityComparer<T>, String, Object[])

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(T, IEnumerable<T>, IEqualityComparer<T>, String, String, String)

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(T, IEnumerable<T>, IEqualityComparer<T>, String)

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(T, IEnumerable<T>, IEqualityComparer<T>)

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(T, IEnumerable<T>, String, Object[])

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(T, IEnumerable<T>, String, String, String)

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(T, IEnumerable<T>, String)

测试指定的集合是否不包含指定的项。
DoesNotContain<T>(T, IEnumerable<T>)

测试指定的集合是否不包含指定的项。
DoesNotContainAll(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)

测试是否collection不包含（具有多重性）的每个元素，如果每个元素notExpectednotExpected至少在发生多次collection时引发异常。
DoesNotContainAll(IEnumerable, IEnumerable, String, String, String)

测试是否collection不包含（具有多重性）的每个元素，如果每个元素notExpectednotExpected至少在发生多次collection时引发异常。
DoesNotContainAll<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)

测试是否collection不包含（具有多重性）的每个元素，如果每个元素notExpectednotExpected至少在发生多次collection时引发异常。
DoesNotContainAll<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)

测试是否collection不包含（具有多重性）的每个元素，如果每个元素notExpectednotExpected至少在发生多次collection时引发异常。
DoesNotEndWith(String, String, String, String, String)

测试指定的字符串是否不以指定的意外后缀结尾，如果测试字符串以后缀结尾，则引发异常。
DoesNotEndWith(String, String, String)

测试指定的字符串是否不以指定的子字符串结尾，如果测试字符串不以子字符串结尾，则引发异常。
DoesNotEndWith(String, String, StringComparison, String, String, String)

测试指定的字符串是否不以指定的意外后缀结尾，如果测试字符串以后缀结尾，则引发异常。
DoesNotEndWith(String, String, StringComparison, String)

测试指定的字符串是否不以指定的子字符串结尾，如果测试字符串不以子字符串结尾，则引发异常。
DoesNotMatchRegex(Regex, String, String, String, String)

测试指定的字符串是否与正则表达式不匹配，并在字符串 MatchsRegex 表达式时引发异常。
DoesNotMatchRegex(Regex, String, String)

测试指定的字符串是否与正则表达式不匹配，并在字符串 MatchsRegex 表达式时引发异常。
DoesNotMatchRegex(String, String, String, String, String)

测试指定的字符串是否与正则表达式不匹配，并在字符串 MatchsRegex 表达式时引发异常。
DoesNotMatchRegex(String, String, String)

测试指定的字符串是否与正则表达式不匹配，并在字符串 MatchsRegex 表达式时引发异常。
DoesNotStartWith(String, String, String, String, String)

测试指定的字符串是否以指定的意外前缀开头，如果测试字符串以前缀开头，则引发异常。
DoesNotStartWith(String, String, String)

测试指定的字符串是否不以指定的子字符串开头，如果测试字符串以子字符串开头，则引发异常。
DoesNotStartWith(String, String, StringComparison, String, String, String)

测试指定的字符串是否以指定的意外前缀开头，如果测试字符串以前缀开头，则引发异常。
DoesNotStartWith(String, String, StringComparison, String)

测试指定的字符串是否不以指定的子字符串开头，如果测试字符串以子字符串开头，则引发异常。
EndsWith(String, String, String, String, String)

测试指定的字符串是否以指定的后缀结尾，如果测试字符串不以后缀结尾，则引发异常。
EndsWith(String, String, String)

测试指定的字符串是否以指定的子字符串结尾，如果测试字符串不以子字符串结尾，则引发异常。
EndsWith(String, String, StringComparison, String, String, String)

测试指定的字符串是否以指定的后缀结尾，如果测试字符串不以后缀结尾，则引发异常。
EndsWith(String, String, StringComparison, String)

测试指定的字符串是否以指定的子字符串结尾，如果测试字符串不以子字符串结尾，则引发异常。
Equals(Object, Object)
已过时.
已过时.

静态相等重载用于比较两种类型的实例的引用相等性。 此方法不应用于比较两个实例是否相等。 请在单元测试中使用 Assert.AreEqual 和相关重载。
Fail()

引发 AssertFailedException。
Fail(String, Object[])

引发 AssertFailedException。
Fail(String)

引发 AssertFailedException。
HasCount(Int32, IEnumerable, String, String)

测试集合是否具有预期的计数/长度。
HasCount(Int32, IEnumerable, String)

测试集合是否具有预期的计数/长度。
HasCount(Int32, IEnumerable)

测试集合是否具有预期的计数/长度。
HasCount<T>(Int32, IEnumerable<T>, Assert.AssertCountInterpolatedStringHandler<T>, String)

测试集合是否具有预期的计数/长度。
HasCount<T>(Int32, IEnumerable<T>, Assert.AssertCountInterpolatedStringHandler<T>)

测试集合是否具有预期的计数/长度。
HasCount<T>(Int32, IEnumerable<T>, String, Object[])

测试集合是否具有预期的计数/长度。
HasCount<T>(Int32, IEnumerable<T>, String, String)

测试集合是否具有预期的计数/长度。
HasCount<T>(Int32, IEnumerable<T>, String)

测试集合是否具有预期的计数/长度。
HasCount<T>(Int32, IEnumerable<T>)

测试集合是否具有预期的计数/长度。
HasCount<T>(Int32, Memory<T>, Assert.AssertCountInterpolatedStringHandler<T>, String)

测试内存是否具有预期的计数/长度。
HasCount<T>(Int32, Memory<T>, String, String)

测试内存是否具有预期的计数/长度。
HasCount<T>(Int32, ReadOnlyMemory<T>, Assert.AssertCountInterpolatedStringHandler<T>, String)

测试内存是否具有预期的计数/长度。
HasCount<T>(Int32, ReadOnlyMemory<T>, String, String)

测试内存是否具有预期的计数/长度。
HasCount<T>(Int32, ReadOnlySpan<T>, Assert.AssertCountInterpolatedStringHandler<T>, String)

测试跨度是否具有预期的计数/长度。
HasCount<T>(Int32, ReadOnlySpan<T>, String, String)

测试跨度是否具有预期的计数/长度。
HasCount<T>(Int32, Span<T>, Assert.AssertCountInterpolatedStringHandler<T>, String)

测试跨度是否具有预期的计数/长度。
HasCount<T>(Int32, Span<T>, String, String)

测试跨度是否具有预期的计数/长度。
Inconclusive()

引发 AssertInconclusiveException。
Inconclusive(String, Object[])

引发 AssertInconclusiveException。
Inconclusive(String)

引发 AssertInconclusiveException。
IsEmpty(IEnumerable, String, String)

测试集合是否为空。
IsEmpty(IEnumerable, String)

测试集合是否为空。
IsEmpty(IEnumerable)

测试集合是否为空。
IsEmpty<T>(IEnumerable<T>, Assert.AssertCountInterpolatedStringHandler<T>, String)

测试集合是否为空。
IsEmpty<T>(IEnumerable<T>, Assert.AssertCountInterpolatedStringHandler<T>)

测试集合是否为空。
IsEmpty<T>(IEnumerable<T>, String, Object[])

测试集合是否为空。
IsEmpty<T>(IEnumerable<T>, String, String)

测试集合是否为空。
IsEmpty<T>(IEnumerable<T>, String)

测试集合是否为空。
IsEmpty<T>(IEnumerable<T>)

测试集合是否为空。
IsExactInstanceOfType(Object, Type, Assert+AssertIsExactInstanceOfTypeInterpolatedStringHandler, String)

测试指定的对象是否正好是预期类型的实例，如果预期类型不匹配，则会引发异常。
IsExactInstanceOfType(Object, Type, String, String)

测试指定的对象是否正好是预期类型的实例，如果预期类型不匹配，则会引发异常。
IsExactInstanceOfType<T>(Object, Assert.AssertGenericIsExactInstanceOfTypeInterpolatedStringHandler<T>, String)

测试指定的对象是否正好是泛型类型的实例，如果泛型类型不匹配，则会引发异常。
IsExactInstanceOfType<T>(Object, String, String)

测试指定的对象是否正好是泛型类型的实例，如果泛型类型不匹配，则会引发异常。
IsFalse(Boolean, Assert+AssertIsFalseInterpolatedStringHandler)

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsFalse(Boolean, String, Object[])

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsFalse(Boolean, String)

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsFalse(Boolean)

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsFalse(Nullable<Boolean>, Assert+AssertIsFalseInterpolatedStringHandler, String)

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsFalse(Nullable<Boolean>, Assert+AssertIsFalseInterpolatedStringHandler)

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsFalse(Nullable<Boolean>, String, Object[])

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsFalse(Nullable<Boolean>, String, String)

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsFalse(Nullable<Boolean>, String)

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsFalse(Nullable<Boolean>)

测试指定的条件是否为 false，如果条件为 true，则引发异常。
IsGreaterThan<T>(T, T, String, String, String)

测试该值是否大于下限，如果不是，则会引发异常。
IsGreaterThan<T>(T, T, String)

测试该值是否大于下限，如果不是，则会引发异常。
IsGreaterThanOrEqualTo<T>(T, T, String, String, String)

测试该值是否大于或等于下限，如果不是，则会引发异常。
IsGreaterThanOrEqualTo<T>(T, T, String)

测试该值是否大于或等于下限，如果不是，则会引发异常。
IsInRange<T>(T, T, T, String, String, String, String)

测试指定的值是否在预期范围内（含）。 范围包括最小值和最大值。
IsInRange<T>(T, T, T, String)

测试指定的值是否在预期范围内（含）。 范围包括最小值和最大值。
IsInstanceOfType(Object, Type, Assert+AssertIsInstanceOfTypeInterpolatedStringHandler, String)

测试指定的对象是否为预期类型的实例，如果预期的类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType(Object, Type, Assert+AssertIsInstanceOfTypeInterpolatedStringHandler)

测试指定的对象是否为预期类型的实例，如果预期的类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType(Object, Type, String, Object[])

测试指定的对象是否为预期类型的实例，如果预期的类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType(Object, Type, String, String)

测试指定的对象是否为预期类型的实例，如果预期的类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType(Object, Type, String)

测试指定的对象是否为预期类型的实例，如果预期的类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType(Object, Type)

测试指定的对象是否为预期类型的实例，如果预期的类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object, Assert.AssertGenericIsInstanceOfTypeInterpolatedStringHandler<T>, String)

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object, Assert.AssertGenericIsInstanceOfTypeInterpolatedStringHandler<T>)

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object, String, Object[])

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object, String, String)

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object, String)

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object, T, Assert.AssertGenericIsInstanceOfTypeInterpolatedStringHandler<T>)

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object, T, String, Object[])

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object, T, String)

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object, T)

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsInstanceOfType<T>(Object)

测试指定的对象是否是泛型类型的实例，如果泛型类型不在对象的继承层次结构中，则会引发异常。
IsLessThan<T>(T, T, String, String, String)

测试该值是否小于上限，如果不是，则会引发异常。
IsLessThan<T>(T, T, String)

测试该值是否小于上限，如果不是，则会引发异常。
IsLessThanOrEqualTo<T>(T, T, String, String, String)

测试该值是否小于或等于上限，如果不是，则会引发异常。
IsLessThanOrEqualTo<T>(T, T, String)

测试该值是否小于或等于上限，如果不是，则会引发异常。
IsNegative<T>(T, String, String)

测试指定的值是否为负值，如果未指定值，则引发异常。
IsNegative<T>(T, String)

测试指定的值是否为负值，如果未指定值，则引发异常。
IsNotEmpty(IEnumerable, String, String)

测试集合是否不为空。
IsNotEmpty(IEnumerable, String)

测试集合是否不为空。
IsNotEmpty(IEnumerable)

测试集合是否不为空。
IsNotEmpty<T>(IEnumerable<T>, Assert.AssertIsNotEmptyInterpolatedStringHandler<T>, String)

测试集合是否不为空。
IsNotEmpty<T>(IEnumerable<T>, Assert.AssertIsNotEmptyInterpolatedStringHandler<T>)

测试集合是否不为空。
IsNotEmpty<T>(IEnumerable<T>, String, Object[])

测试集合是否不为空。
IsNotEmpty<T>(IEnumerable<T>, String, String)

测试集合是否不为空。
IsNotEmpty<T>(IEnumerable<T>, String)

测试集合是否不为空。
IsNotEmpty<T>(IEnumerable<T>)

测试集合是否不为空。
IsNotExactInstanceOfType(Object, Type, Assert+AssertIsNotExactInstanceOfTypeInterpolatedStringHandler, String)

测试指定的对象是否完全不是错误的类型的实例，如果指定的类型完全匹配，则会引发异常。
IsNotExactInstanceOfType(Object, Type, String, String)

测试指定的对象是否完全不是错误的类型的实例，如果指定的类型完全匹配，则会引发异常。
IsNotExactInstanceOfType<T>(Object, Assert.AssertGenericIsNotExactInstanceOfTypeInterpolatedStringHandler<T>, String)

测试指定的对象是否完全不是错误的泛型类型的实例，如果指定的类型完全匹配，则会引发异常。
IsNotExactInstanceOfType<T>(Object, String, String)

测试指定的对象是否完全不是错误的泛型类型的实例，如果指定的类型完全匹配，则会引发异常。
IsNotInstanceOfType(Object, Type, Assert+AssertIsNotInstanceOfTypeInterpolatedStringHandler, String)

测试指定的对象是否不是错误的类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType(Object, Type, Assert+AssertIsNotInstanceOfTypeInterpolatedStringHandler)

测试指定的对象是否不是错误的类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType(Object, Type, String, Object[])

测试指定的对象是否不是错误的类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType(Object, Type, String, String)

测试指定的对象是否不是错误的类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType(Object, Type, String)

测试指定的对象是否不是错误的类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType(Object, Type)

测试指定的对象是否不是错误的类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType<T>(Object, Assert.AssertGenericIsNotInstanceOfTypeInterpolatedStringHandler<T>, String)

测试指定的对象是否不是错误的泛型类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType<T>(Object, Assert.AssertGenericIsNotInstanceOfTypeInterpolatedStringHandler<T>)

测试指定的对象是否不是错误的泛型类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType<T>(Object, String, Object[])

测试指定的对象是否不是错误的泛型类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType<T>(Object, String, String)

测试指定的对象是否不是错误的泛型类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType<T>(Object, String)

测试指定的对象是否不是错误的泛型类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotInstanceOfType<T>(Object)

测试指定的对象是否不是错误的泛型类型的实例，如果指定的类型位于对象的继承层次结构中，则会引发异常。
IsNotNull(Object, Assert+AssertIsNotNullInterpolatedStringHandler, String)

测试指定的对象是否为 null，如果未指定对象，则引发异常。
IsNotNull(Object, Assert+AssertIsNotNullInterpolatedStringHandler)

测试指定的对象是否为 null，如果未指定对象，则引发异常。
IsNotNull(Object, String, Object[])

测试指定的对象是否为非 null，如果为 null，则会引发异常。
IsNotNull(Object, String, String)

测试指定的对象是否为非 null，如果为 null，则会引发异常。
IsNotNull(Object, String)

测试指定的对象是否为非 null，如果为 null，则会引发异常。
IsNotNull(Object)

测试指定的对象是否为非 null，如果为 null，则会引发异常。
IsNull(Object, Assert+AssertIsNullInterpolatedStringHandler, String)

测试指定的对象是否为 null，如果未指定对象，则引发异常。
IsNull(Object, Assert+AssertIsNullInterpolatedStringHandler)

测试指定的对象是否为 null，如果未指定对象，则引发异常。
IsNull(Object, String, Object[])

测试指定的对象是否为 null，如果未指定对象，则引发异常。
IsNull(Object, String, String)

测试指定的对象是否为 null，如果未指定对象，则引发异常。
IsNull(Object, String)

测试指定的对象是否为 null，如果未指定对象，则引发异常。
IsNull(Object)

测试指定的对象是否为 null，如果未指定对象，则引发异常。
IsPositive<T>(T, String, String)

测试指定的值是否为正值，如果未指定值，则引发异常。
IsPositive<T>(T, String)

测试指定的值是否为正值，如果未指定值，则引发异常。
IsTrue(Boolean, Assert+AssertIsTrueInterpolatedStringHandler)

测试指定的条件是否为 true，如果条件为 false，则引发异常。
IsTrue(Boolean, String, Object[])

测试指定的条件是否为 true，如果条件为 false，则引发异常。
IsTrue(Boolean, String)

测试指定的条件是否为 true，如果条件为 false，则引发异常。
IsTrue(Boolean)

测试指定的条件是否为 true，如果条件为 false，则引发异常。
IsTrue(Nullable<Boolean>, Assert+AssertIsTrueInterpolatedStringHandler, String)

测试指定的条件是否为 true，如果条件为 false，则引发异常。
IsTrue(Nullable<Boolean>, Assert+AssertIsTrueInterpolatedStringHandler)

测试指定的条件是否为 true，如果条件为 false，则引发异常。
IsTrue(Nullable<Boolean>, String, Object[])

测试指定的条件是否为 true，如果条件为 false，则引发异常。
IsTrue(Nullable<Boolean>, String, String)

测试指定的条件是否为 true，如果条件为 false，则引发异常。
IsTrue(Nullable<Boolean>, String)

测试指定的条件是否为 true，如果条件为 false，则引发异常。
IsTrue(Nullable<Boolean>)

测试指定的条件是否为 true，如果条件为 false，则引发异常。
MatchesRegex(Regex, String, String, String, String)

测试指定的字符串是否匹配正则表达式，并在字符串与表达式不匹配时引发异常。
MatchesRegex(Regex, String, String)

测试指定的字符串是否匹配正则表达式，并在字符串与表达式不匹配时引发异常。
MatchesRegex(String, String, String, String, String)

测试指定的字符串是否匹配正则表达式，并在字符串与表达式不匹配时引发异常。
MatchesRegex(String, String, String)

测试指定的字符串是否匹配正则表达式，并在字符串与表达式不匹配时引发异常。
ReferenceEquals(Object, Object)
已过时.
已过时.

静态 ReferenceEquals 重载用于比较两种类型的实例的引用相等性。 此方法不应用于比较两个实例的引用相等性。 请在单元测试中使用 Assert.AreSame 和相关重载。
ReplaceNullChars(String)

将 null 字符（'\0'）替换为“\0”。
Scope()

创建一个新的断言范围，用于收集断言失败，而不是立即引发它们。 释放返回的范围时，所有收集的失败都会作为单个 AssertFailedException引发。
StartsWith(String, String, String, String, String)

测试指定的字符串是否以指定的前缀开头，如果测试字符串不以前缀开头，则引发异常。
StartsWith(String, String, String)

测试指定的字符串是否以指定的子字符串开头，如果测试字符串不以子字符串开头，则引发异常。
StartsWith(String, String, StringComparison, String, String, String)

测试指定的字符串是否以指定的前缀开头，如果测试字符串不以前缀开头，则引发异常。
StartsWith(String, String, StringComparison, String)

测试指定的字符串是否以指定的子字符串开头，如果测试字符串不以子字符串开头，则引发异常。
Throws<TException>(Action, Assert.AssertNonStrictThrowsInterpolatedStringHandler<TException>, String)

断言委托 action 会引发类型（或派生类型 TException ）的异常，并在 AssertFailedException 代码不引发异常或引发类型以外的 TException异常时引发。
Throws<TException>(Action, Assert.AssertNonStrictThrowsInterpolatedStringHandler<TException>)

断言委托 action 会引发类型（或派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
Throws<TException>(Action, Func<Exception,String>, String)

断言委托 action 会引发类型（或派生类型 TException ）的异常，并在 AssertFailedException 代码不引发异常或引发类型以外的 TException异常时引发。
Throws<TException>(Action, Func<Exception,String>)

断言委托 action 会引发类型（或派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
Throws<TException>(Action, String, Object[])

断言委托 action 会引发类型（或派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
Throws<TException>(Action, String, String)

断言委托 action 会引发类型（或派生类型 TException ）的异常，并在 AssertFailedException 代码不引发异常或引发类型以外的 TException异常时引发。
Throws<TException>(Func<Object>, Assert.AssertNonStrictThrowsInterpolatedStringHandler<TException>, String)

断言委托 action 会引发类型（或派生类型 TException ）的异常，并在 AssertFailedException 代码不引发异常或引发类型以外的 TException异常时引发。
Throws<TException>(Func<Object>, Assert.AssertNonStrictThrowsInterpolatedStringHandler<TException>)

断言委托 action 会引发类型（或派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
Throws<TException>(Func<Object>, Func<Exception,String>, String)

断言委托 action 会引发类型（或派生类型 TException ）的异常，并在 AssertFailedException 代码不引发异常或引发类型以外的 TException异常时引发。
Throws<TException>(Func<Object>, Func<Exception,String>)

断言委托 action 会引发类型（或派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
Throws<TException>(Func<Object>, String, Object[])

断言委托 action 会引发类型（或派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
Throws<TException>(Func<Object>, String, String)

断言委托 action 会引发类型（或派生类型 TException ）的异常，并在 AssertFailedException 代码不引发异常或引发类型以外的 TException异常时引发。
ThrowsAsync<TException>(Func<Task>, Assert.AssertNonStrictThrowsAsyncInterpolatedStringHandler<TException>, String)

断言委托 action 会引发类型（或派生类型 TException ）的异常，并在 AssertFailedException 代码不引发异常或引发类型以外的 TException异常时引发。
ThrowsAsync<TException>(Func<Task>, Func<Exception,String>, String)

断言委托 action 会引发类型（或派生类型 TException ）的异常，并在 AssertFailedException 代码不引发异常或引发类型以外的 TException异常时引发。
ThrowsAsync<TException>(Func<Task>, Func<Exception,String>)

断言委托 action 会引发类型（或派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsAsync<TException>(Func<Task>, String, Object[])

断言委托 action 会引发类型（或派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsAsync<TException>(Func<Task>, String, String)

断言委托 action 会引发类型（或派生类型 TException ）的异常，并在 AssertFailedException 代码不引发异常或引发类型以外的 TException异常时引发。
ThrowsExactly<TException>(Action, Assert.AssertThrowsExactlyInterpolatedStringHandler<TException>, String)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则会引发。
ThrowsExactly<TException>(Action, Assert.AssertThrowsExactlyInterpolatedStringHandler<TException>)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsExactly<TException>(Action, Func<Exception,String>, String)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则会引发。
ThrowsExactly<TException>(Action, Func<Exception,String>)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsExactly<TException>(Action, String, Object[])

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsExactly<TException>(Action, String, String)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则会引发。
ThrowsExactly<TException>(Func<Object>, Assert.AssertThrowsExactlyInterpolatedStringHandler<TException>, String)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则会引发。
ThrowsExactly<TException>(Func<Object>, Assert.AssertThrowsExactlyInterpolatedStringHandler<TException>)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsExactly<TException>(Func<Object>, Func<Exception,String>, String)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则会引发。
ThrowsExactly<TException>(Func<Object>, Func<Exception,String>)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsExactly<TException>(Func<Object>, String, Object[])

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsExactly<TException>(Func<Object>, String, String)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则会引发。
ThrowsExactlyAsync<TException>(Func<Task>, Assert.AssertThrowsExactlyAsyncInterpolatedStringHandler<TException>, String)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则会引发。
ThrowsExactlyAsync<TException>(Func<Task>, Func<Exception,String>, String)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则会引发。
ThrowsExactlyAsync<TException>(Func<Task>, Func<Exception,String>)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsExactlyAsync<TException>(Func<Task>, String, Object[])

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则引发异常。
ThrowsExactlyAsync<TException>(Func<Task>, String, String)

断言委托 action 会引发类型（而不是派生类型 TException ）的异常，如果 AssertFailedException 代码不引发异常或引发类型以外的 TException异常，则会引发。
ThrowsException<T>(Action, String, Object[])

测试委托action指定的代码是否引发类型（而不是派生类型T）的确切给定异常，如果代码不引发异常或引发类型以外的AssertFailedException异常，则会引发T。
ThrowsException<T>(Action, String)

测试委托action指定的代码是否引发类型（而不是派生类型T）的确切给定异常，如果代码不引发异常或引发类型以外的AssertFailedException异常，则会引发T。
ThrowsException<T>(Action)

测试委托action指定的代码是否引发类型（而不是派生类型T）的确切给定异常，如果代码不引发异常或引发类型以外的AssertFailedException异常，则会引发T。
ThrowsException<T>(Func<Object>, String, Object[])

测试委托action指定的代码是否引发类型（而不是派生类型T）的确切给定异常，如果代码不引发异常或引发类型以外的AssertFailedException异常，则会引发T。
ThrowsException<T>(Func<Object>, String)

测试委托action指定的代码是否引发类型（而不是派生类型T）的确切给定异常，如果代码不引发异常或引发类型以外的AssertFailedException异常，则会引发T。
ThrowsException<T>(Func<Object>)

测试委托action指定的代码是否引发类型（而不是派生类型T）的确切给定异常，如果代码不引发异常或引发类型以外的AssertFailedException异常，则会引发T。
ThrowsExceptionAsync<T>(Func<Task>, String, Object[])

测试委托action指定的代码是否引发类型（而不是派生类型T）的确切给定异常，如果代码不引发异常或引发类型以外的AssertFailedException异常，则会引发T。
ThrowsExceptionAsync<T>(Func<Task>, String)

测试委托action指定的代码是否引发类型（而不是派生类型T）的确切给定异常，如果代码不引发异常或引发类型以外的AssertFailedException异常，则会引发T。
ThrowsExceptionAsync<T>(Func<Task>)

测试委托action指定的代码是否引发类型（而不是派生类型T）的确切给定异常，如果代码不引发异常或引发类型以外的AssertFailedException异常，则会引发T。

适用于