Microsoft.VisualStudio.Validation Common runtime checks that throw exceptions upon failure. Contains the inner exception thrown by Assumes. Throws if the specified value is null. The type of value to test. Throws if the specified value is null. The type of value to test. Throws if the specified value is null or empty. Throws if the specified value is null or empty. The type of value to test. Throws if the specified value is null or empty. The type of value to test. Throws if the specified value is not null. The type of value to test. Throws if the specified value is not null. The type of value to test. Throws if the specified object is not of a given type. The type the value is expected to be. The value to test. Throws an public exception if a condition evaluates to true. Throws an public exception if a condition evaluates to true. Throws an public exception if a condition evaluates to true. Throws an public exception if a condition evaluates to true. Throws an public exception if a condition evaluates to false. Throws an public exception if a condition evaluates to false. Throws an public exception if a condition evaluates to false. Throws an public exception if a condition evaluates to false. Unconditionally throws an . Nothing. This method always throws. Unconditionally throws an . The type that the method should be typed to return (although it never returns anything). Nothing. This method always throws. Verifies that a value is not null, and throws about a missing service otherwise. The interface of the imported part. Throws an public exception. Nothing, as this method always throws. The signature allows for "throwing" Fail so C# knows execution will stop. Throws an public exception. Nothing, as this method always throws. The signature allows for "throwing" Fail so C# knows execution will stop. Throws an public exception. Nothing, as this method always throws. The signature allows for "throwing" Fail so C# knows execution will stop. Throws an public exception. Nothing, as this method always throws. The signature allows for "throwing" Fail so C# knows execution will stop. Helper method that formats string arguments. The exception that is thrown when an internal assumption failed. Initializes a new instance of the class. Initializes a new instance of the class. Initializes a new instance of the class. Extension methods to make it easier to safely invoke events. Invokes any event handlers that are hooked to the specified event. The event. Null is allowed. The value to pass as the sender of the event. Event arguments to include. Invokes any event handlers that are hooked to the specified event. The event. Null is allowed. The value to pass as the sender of the event. Event arguments to include. Invokes any event handlers that are hooked to the specified event. The type of EventArgs. The event. Null is allowed. The value to pass as the sender of the event. Event arguments to include. Extension methods for exceptions. Adds data to the Data member of before returning the modified exception. The type of exception being modified. The exception to add data to. The key to use for the added data. The values to add with the given . A reference to the same . This method should be used to add context (beyond the message and callstack we normally get) to the exception that would be useful when debugging Watson crashes. Do not use this method when you expect the exception to be handled. A disposable object that also provides a safe way to query its disposed status. Gets a value indicating whether this instance has been disposed. if this instance has been disposed. Common utility methods used by the various error detection and reporting classes. Trims away a given surrounding type, returning just the generic type argument, if the given type is in fact a generic type with just one type argument and the generic type matches a given wrapper type. Otherwise, it returns the original type. The type to trim, or return unmodified. The SomeType<> generic type definition to trim away from if it is present. , if it is not a generic type instance of ; otherwise the type argument. Helper method that formats string arguments. The formatted string. Common runtime checks that trace messages and invoke an assertion failure, but does *not* throw exceptions. Verifies that a value is not null, and reports an error about a missing MEF component otherwise. The interface of the imported part. Reports an error if a condition evaluates to true. Reports an error if a condition does not evaluate to true. Reports an error if a condition does not evaluate to true. Reports an error if a condition does not evaluate to true. Reports an error if a condition does not evaluate to true. Reports an error if a condition does not evaluate to true. Reports a certain failure. Reports a certain failure. Common runtime checks that throw ArgumentExceptions upon failure. Throws an exception if the specified parameter's value is null. The type of the parameter. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. The value of the parameter. Thrown if is . Throws an exception if the specified parameter's value is IntPtr.Zero. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. The value of the parameter. Thrown if is . Throws an exception if the specified parameter's value is null. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if is . This method allows async methods to use Requires.NotNull without having to assign the result to local variables to avoid C# warnings. Throws an exception if the specified parameter's value is null. The type of the return value of the task. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if is . This method allows async methods to use Requires.NotNull without having to assign the result to local variables to avoid C# warnings. Throws an exception if the specified parameter's value is null. The type of the parameter. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. The value of the parameter. Thrown if is . This method exists for callers who themselves only know the type as a generic parameter which may or may not be a class, but certainly cannot be null. Throws an exception if the specified parameter's value is null or empty. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if is or empty. Throws an exception if the specified parameter's value is null, empty, or whitespace. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if is or empty. Throws an exception if the specified parameter's value is null, has no elements. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if the tested condition is false. Throws an exception if the specified parameter's value is null, has no elements. The type produced by the enumeration. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if the tested condition is false. Throws an exception if the specified parameter's value is null, has no elements. The type of value in the collection. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if the tested condition is false. Throws an exception if the specified parameter's value is null, has no elements or has an element with a null value. The type of the elements in the sequence. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if the tested condition is false. Throws an exception if the specified parameter's value is not null and has an element with a null value. The type of the elements in the sequence. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if the tested condition is false. Throws an exception if the specified parameter's value is . The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if is an empty guid (.) Throws an if a condition does not evaluate to true. Throws an if a condition does not evaluate to true. Nothing. This method always throws. Throws an if a condition does not evaluate to true. Throws an if a condition does not evaluate to true. Throws an if a condition does not evaluate to true. Throws an if a condition does not evaluate to true. Throws an if a condition does not evaluate to true. Throws an if a condition does not evaluate to true. The condition to check. The name of the parameter to blame in the exception, if thrown. The resource manager from which to retrieve the exception message. For example: Strings.ResourceManager. The name of the string resource to obtain for the exception message. For example: nameof(Strings.SomeError). Thrown if is . Thrown if is . This overload allows only loading a localized string in the error condition as an optimization in perf critical sections over the simpler to use overload. The name of the string resource to obtain for the exception message. For example: nameof(Strings.SomeError). The first formatting argument. The second formatting argument. The name of the string resource to obtain for the exception message. For example: nameof(Strings.SomeError). The formatting arguments. Throws an ArgumentException. Nothing. It always throws. Throws an ArgumentException. Nothing. It always throws. Throws an ArgumentException. Nothing. This method always throws. Throws an if a given value is not a named value of the enum type. The type of enum that may define the . The value that may be named by . The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Throws an if the specified parameter's value is equal to the default value of the . The type of the parameter. The value of the argument. The name of the parameter to include in any thrown exception. If this argument is omitted (explicitly writing does not qualify), the expression used in the first argument will be used as the parameter name. Thrown if is or empty. Throws an exception if is null, is null, or if is not null and has an element which does not match the given predicate. The type of the elements in the sequence. The value of the argument. The predicate used to test the elements. The name of the parameter to include in any thrown exception. A message to be used in the resulting exception. Thrown if the tested condition is false. Thrown if or is . Throws an exception if is null, is null, or if is not null and has an element which does not match the given predicate. The type of the elements in the sequence. The value of the argument. The predicate used to test the elements. The name of the parameter to include in any thrown exception. The unformatted message. Formatting arguments. Thrown if the tested condition is false. Thrown if is . Helper method that formats string arguments. Indicates to Code Analysis that a method validates a particular parameter. Initializes a new instance of the class. Provides an interpolated string handler for validation functions that only perform formatting if the condition check fails. Initializes a new instance of the struct. The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. The condition Boolean passed to the method. A value indicating whether formatting should proceed. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. Writes the specified string to the handler. The string to write. Writes the specified value to the handler. The value to write. The type of the value to write. Writes the specified value to the handler. The value to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The format string. The type of the value to write. Extracts the built string from the handler. The formatted string. Provides an interpolated string handler for validation functions that only perform formatting if the condition check fails. Initializes a new instance of the struct. The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. The condition Boolean passed to the method. A value indicating whether formatting should proceed. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. Writes the specified string to the handler. The string to write. Writes the specified value to the handler. The value to write. The type of the value to write. Writes the specified value to the handler. The value to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The format string. The type of the value to write. Extracts the built string from the handler. The formatted string. Common runtime checks that throw exceptions upon failure. Throws an if a condition is false. Throws an if a condition is false. Throws an if a condition is false. Throws an if a condition is false. Throws an if a condition is false. Throws an if a condition is false. Throws an . Nothing. This method always throws. The signature claims to return an exception to allow callers to throw this method to satisfy C# execution path constraints. Throws an . Nothing. This method always throws. The signature claims to return an exception to allow callers to throw this method to satisfy C# execution path constraints. Throws an if an object is disposed. Throws an if a condition is false. Throws an if a condition is false. Throws an exception if the given value is negative. The HRESULT corresponding to the desired exception. If true, prevents ThrowExceptionForHR from returning an exception from a previous COM call and instead always use the HRESULT specified. No exception is thrown for S_FALSE. '{0}' must contain at least one element. '{0}' must contain at least one element. '{0}' cannot be an empty guid. '{0}' cannot be an empty guid. '{0}' cannot be an empty string ("") or start with the null character. '{0}' cannot be an empty string ("") or start with the null character. The value of argument '{0}' ({1}) is invalid for Enum type '{2}'. The value of argument '{0}' ({1}) is invalid for Enum type '{2}'. '{0}' cannot contain a null (Nothing in Visual Basic) element. '{0}' cannot contain a null (Nothing in Visual Basic) element. '{0}' cannot be the default value defined by '{1}'. '{0}' cannot be the default value defined by '{1}'. The argument cannot consist entirely of white space characters. An internal error occurred. Please contact Microsoft Support. Cannot find an instance of the {0} service. Cannot find an instance of the {0} service. DQUtriWZHbh0Z3u95AAD9SBaIjfugH5VB5fJZ3+kHfg=thdoOzxQkuOUAXCcyhtqwKm1DiJq1g+YsEm/zdzesDouK7hH3aDJ/vxjHKBLwGVUMAhD3lES2yzmWHeH/yr7ftZFkbqWvUkM8ZJsGwWiHA4IQCQh9lpt4E0aZdHLI/EEcUUCNqa8oiqcmKQGC488JQm/iz5jto/MKzowKikg0bas2HyvYTH3gIDbcRsMsYLIErLgYPkR1FQw9fan6NVvgh9pPq7wxy0sNM8BRjxuzWtrIHpxHbdp8onRwmRqf2JfzcPCeh82oBAXiwHmmIghDDRmyOUjDWt6DZmZqRpFFOE+V30otf4NvabzKrC66QXJXe4Z37n7LyDWFpYCQgASfA==3QiojSOiARVrryVJn+lnTiamZiMGLORuwCQ+VG3C+rbAvhATw269+qRRqNW7FKed50chWJ53KDIPBStHfIy5cNJYHsQw6+4InH9szgRVqn7/50i8MyRTT+VtNwxf9daGddq0hahpZvjuOnEY0wxQaTEQmWRnXWZUQY4r28tHiNVYEw9U7wHXwWEHvNn4ZlkJGEf5VpgCvr1v9fmzu4x2sV0zQsSyAVtOxfDwY1HMBcccn23tphweIdS+FNDn2vh1/2kREO0qmGc+fbFzNskjn72MiI56kjvNDRgWs+Q78yBvPCdPgTYTrto5eg33Ko2ELNR/zzEkCCuhO5Vw10qV8w==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