public static T IsOrIsDerivedFrom <T>(object parameter, string parameterName)
{
ValidateArgument.IsNotNull(parameterName, nameof(parameterName));
ValidateArgument.IsNotNull(parameter, parameterName);
if (!(parameter is T))
{
var message = $"Type of argument is not equal to or derived from type {typeof(T)}: {parameter.GetType()}";
throw new ArgumentException(message, parameterName);
}
return((T)parameter);
}
public static T IsDerivedFrom <T>(object parameter, string parameterName)
where T : class
{
ValidateArgument.IsNotNull(parameterName, nameof(parameterName));
ValidateArgument.IsNotNull(parameter, parameterName);
if (typeof(T) == parameter.GetType() || !(parameter is T))
{
var message = $"Type of argument is not derived from type ${typeof(T)}: {parameter.GetType()}";
throw new ArgumentException(message, parameterName);
}
return((T)parameter);
}
/// <summary>
/// Throws <see cref="ArgumentNullException"/> if the specified argument is null, or <see cref="ArgumentException"/>
/// if the specified argument empty, or contains only whitespace.
/// </summary>
/// <param name="parameter">The argument.</param>
/// <param name="parameterName">The argument name.</param>
/// <param name="message">A message that describes the error. Optional.</param>
/// <exception cref="ArgumentNullException">Either <paramref name="parameterName"/> or <paramref name="parameter"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">The <paramref name="parameter"/> is empty or contains only whitespace.</exception>
/// <returns><paramref name="parameter"/></returns>
public static string IsNotNullOrWhiteSpace(string parameter, string parameterName, string message = null)
{
ValidateArgument.IsNotNull(parameterName, nameof(parameterName));
if (parameter == null)
{
throw new ArgumentNullException(parameterName, message);
}
else if (string.IsNullOrWhiteSpace(parameter))
{
var exceptionMessage = message ?? "Argument cannot be null, empty, or contain only whitespace.";
throw new ArgumentException(parameterName, message);
}
return(parameter);
}
public static T ImplementsInterface <T>(object parameter, string parameterName)
where T : class
{
ValidateArgument.IsNotNull(parameterName, nameof(parameterName));
ValidateArgument.IsNotNull(parameter, parameterName);
if (!typeof(T).GetTypeInfo().IsInterface)
{
var message = string.Format("Generic argument type is not an interface: {0}", typeof(T));
throw new ArgumentException(message, nameof(T));
}
var result = parameter as T;
if (result == null)
{
var message = string.Format("Type of argument does not implement interface type {0}: {1}", typeof(T), parameter.GetType());
throw new ArgumentException(message, parameterName);
}
return(result);
}
public DisposeActionScope(Action disposeAction)
{
ValidateArgument.IsNotNull(disposeAction, nameof(disposeAction));
_disposeAction = disposeAction;
}
public DisposeActionScope(Action initializeAction, Action disposeAction)
: this(disposeAction)
{
ValidateArgument.IsNotNull(initializeAction, nameof(initializeAction));
initializeAction();
}
