public static IArgumentValidation <IEnumerable <T?>?> IsNotEmpty <T>(this IArgumentValidation <IEnumerable <T?>?> argumentValidation)
{
argumentValidation.Validate(
enumerable => enumerable == null || enumerable.Any(),
parameterName => new ArgumentException(Resources.EnumerableConstraints.IsNotEmptyErrorMessage, parameterName));
return(argumentValidation);
}
public static IArgumentValidation <string?> DoesNotMatch(
this IArgumentValidation <string?> argumentValidation,
[RegexPattern] string pattern,
RegexOptions options = RegexOptions.None)
{
return(argumentValidation.DoesNotMatch(new Regex(pattern, options)));
}
public static IArgumentValidation <T> IsFlag <T>(this IArgumentValidation <T> argumentValidation)
where T : Enum
{
return(argumentValidation.Validate(
value => value.IsFlag(),
parameterName => new ArgumentException(Resources.EnumConstraints.IsFlagErrorMessage(typeof(T)), parameterName)));
}
public static IArgumentValidation <string?> Matches(this IArgumentValidation <string?> argumentValidation, Regex regularExpression)
{
return(argumentValidation.Validate(
value => value == null || regularExpression.IsMatch(value),
parameterName => new ArgumentException(
Resources.StringConstraints.MatchesErrorMessage(argumentValidation.Value, regularExpression.ToString()),
parameterName)));
}
public static IArgumentValidation <T?> IsNotEqualTo <T>(this IArgumentValidation <T?> argumentValidation, T valueToCompare)
where T : struct, IComparable <T>
{
if (argumentValidation.Value != null)
{
argumentValidation.IsNotEqualTo(argumentValidation.Value.Value, valueToCompare);
}
return(argumentValidation);
}
internal static void IsLessThan <T>(this IArgumentValidation argumentValidation, T?value, T?valueToCompare)
where T : IComparable <T>
{
argumentValidation.ValidateComparison(
value,
valueToCompare,
result => result < 0,
Resources.ComparisonConstraints.IsLessThanErrorMessage(value, valueToCompare));
}
internal static void Validate(
this IArgumentValidation argumentValidation,
Func <bool> condition,
Func <string, ArgumentException> exceptionFactory)
{
if (!condition())
{
argumentValidation.AddException(exceptionFactory(argumentValidation.Name));
}
}
public static IArgumentValidation <string?> Matches(
this IArgumentValidation <string?> argumentValidation,
[RegexPattern] string pattern,
RegexOptions options = RegexOptions.None)
{
Requires.Argument(pattern, nameof(pattern))
.IsNotEmpty()
.Check();
return(argumentValidation.Matches(new Regex(pattern, options)));
}
internal static IArgumentValidation <T> Validate <T>(
this IArgumentValidation <T> argumentValidation,
Func <T?, bool> condition,
Func <string, ArgumentException> exceptionFactory)
{
if (!condition(argumentValidation.Value))
{
argumentValidation.AddException(exceptionFactory(argumentValidation.Name));
}
return(argumentValidation);
}
private static void ValidateComparison <T>(
this IArgumentValidation argumentValidation,
T?value,
T?valueToCompare,
Func <int?, bool> validateComparisonResult,
string errorMessage)
where T : IComparable <T>
{
argumentValidation.Validate(
() => validateComparisonResult(value?.CompareTo(valueToCompare)),
paramName => new ArgumentException(errorMessage, paramName));
}
public static void Check <T>(this IArgumentValidation <T>?argumentValidation)
{
if (argumentValidation == null)
{
return;
}
var exceptions = argumentValidation.Exceptions;
switch (exceptions.Count)
{
case 0:
return;
case 1:
throw exceptions.Single();
default:
throw new AggregateArgumentException(Resources.AggregateArgumentException.DefaultErrorMessage, argumentValidation.Name, exceptions);
}
}
internal static T?GetValueOrDefault <T>(this IArgumentValidation <T?> argumentValidation)
{
return(argumentValidation.Value);
}
public static IArgumentValidation <T> DoesNotEqualTo <T>(this IArgumentValidation <T> argumentValidation, T?valueToCompare)
where T : IEquatable <T>?
{
return(argumentValidation.Validate(
public static IArgumentValidation <ICollection <T?> > IsNotNullOrEmpty <T>(this IArgumentValidation <ICollection <T?> > argumentValidation)
{
return(argumentValidation.Validate(
collection => collection is { Count: > 0 },
public static IArgumentValidation <ICollection <T?> > IsNotEmpty <T>(this IArgumentValidation <ICollection <T?> > argumentValidation)
{
return(argumentValidation.Validate(
collection => collection == null || collection.Count > 0,
parameterName => new ArgumentException(Resources.CollectionConstraints.IsNotEmptyErrorMessage, parameterName)));
}
public static IArgumentValidation <ICollection <T?> > ContainsSingle <T>(this IArgumentValidation <ICollection <T?> > argumentValidation)
{
return(argumentValidation.Validate(
collection => collection == null || collection.Count == 1,
parameterName => new ArgumentException(Resources.CollectionConstraints.ContainsSingleErrorMessage, parameterName)));
}
public static IArgumentValidation <T?> IsNotEqualTo <T>(this IArgumentValidation <T?> argumentValidation, T valueToCompare)
where T : IComparable <T?>
{
argumentValidation.IsNotEqualTo(argumentValidation.GetValueOrDefault(), valueToCompare);
return(argumentValidation);
}
public static IArgumentValidation <T> IsNotNull <T>(this IArgumentValidation <T> argumentValidation)
{
return(argumentValidation.Validate(value => !Equals(null, value), parameterName => new ArgumentNullException(parameterName)));
}
public static IArgumentValidation <string?> IsNotNullOrWhiteSpace(this IArgumentValidation <string?> argumentValidation)
{
return(argumentValidation.Validate(
value => !string.IsNullOrWhiteSpace(value),
parameterName => new ArgumentException(Resources.StringConstraints.IsNotNullOrWhiteSpaceErrorMessage, parameterName)));
}
public static IArgumentValidation <string?> IsNotEmpty(this IArgumentValidation <string?> argumentValidation)
{
return(argumentValidation.Validate(
value => value == null || value.Length > 0,
parameterName => new ArgumentException(Resources.StringConstraints.IsNotEmptyErrorMessage, parameterName)));
}
public static IArgumentValidation <ICollection <T?> > DoesNotContainNullElement <T>(this IArgumentValidation <ICollection <T?> > argumentValidation)
{
return(argumentValidation.Validate(
collection => collection == null || !collection.Any() || collection.Any(element => !Equals(element, null)),
parameterName => new ArgumentException(Resources.CollectionConstraints.DoesNotContainNullElementErrorMessage, parameterName)));
}
public static IArgumentValidation <Type?> IsInterface(this IArgumentValidation <Type?> argumentValidation)
{
return(argumentValidation.Validate(
type => type?.IsInterface ?? true,
parameterName => new ArgumentException(Resources.TypeConstraints.IsInterfaceErrorMessage(argumentValidation.Value), parameterName)));
}
public static IArgumentValidation <T?> IsLessThan <T>(this IArgumentValidation <T?> argumentValidation, T?valueToCompare)
where T : IComparable <T>
{
argumentValidation.IsLessThan(argumentValidation.GetValueOrDefault(), valueToCompare);
return(argumentValidation);
}
