// ReSharper disable once UnusedParameter.Local
private static void ThrowIfNotComparable(
Validation validation,
TypeValidation typeValidation)
{
var valueType = validation.ValueType;
// type is nullable
if (Nullable.GetUnderlyingType(valueType) == null)
{
// type is IComparable or can be assigned to IComparable
if ((valueType != ComparableType) && (!ComparableType.IsAssignableFrom(valueType)))
{
// type is IComparable<T>
if ((!valueType.IsGenericType) || (valueType.GetGenericTypeDefinition() != UnboundGenericComparableType))
{
// type implements IComparable<T>
var comparableType = valueType.GetInterfaces().FirstOrDefault(_ => _.IsGenericType && (_.GetGenericTypeDefinition() == UnboundGenericEnumerableType));
if (comparableType == null)
{
// note that, for completeness, we should recurse through all interface implementations
// and check whether any of those are IComparable<>
// see: https://stackoverflow.com/questions/5461295/using-isassignablefrom-with-open-generic-types
ThrowParameterUnexpectedType(validation, nameof(IComparable), ComparableGenericTypeName, NullableGenericTypeName);
}
}
}
}
}
// ReSharper disable once UnusedParameter.Local
private static void Throw(
Validation validation,
TypeValidation typeValidation)
{
var parameterValueTypeName = validation.ValueType.GetFriendlyTypeName();
throw new InvalidCastException(Invariant($"validationName: {validation.ValidationName}, isElementInEnumerable: {validation.IsElementInEnumerable}, parameterValueTypeName: {parameterValueTypeName}"));
}
private static void ThrowIfTypeCannotBeNull(
Validation validation,
TypeValidation typeValidation)
{
var valueType = validation.ValueType;
if (valueType.IsValueType && (Nullable.GetUnderlyingType(valueType) == null))
{
ThrowParameterUnexpectedType(validation, AnyReferenceTypeName, NullableGenericTypeName);
}
}
private static void ThrowIfNotOfType(
Validation validation,
TypeValidation typeValidation)
{
var valueType = validation.ValueType;
var validTypes = typeValidation.ReferenceTypes;
if (!validTypes.Any(_ => valueType.IsOfType(_)))
{
ThrowParameterUnexpectedType(validation, validTypes);
}
}
// ReSharper disable once UnusedParameter.Local
private static void ThrowIfNotOfType(
Validation validation,
TypeValidation typeValidation)
{
var valueType = validation.ValueType;
var validTypes = typeValidation.ReferenceTypes;
if ((!validTypes.Contains(valueType)) && (!validTypes.Any(_ => _.IsAssignableFrom(valueType))))
{
ThrowParameterUnexpectedType(validation, validTypes);
}
}
private static void ThrowIfNotOfType(
Validation validation,
TypeValidation typeValidation)
{
var valueType = validation.ValueType;
var validTypes = typeValidation.ReferenceTypes;
if (!validTypes.Any(_ => valueType.IsAssignableTo(_, treatUnboundGenericAsAssignableTo: true)))
{
ThrowParameterUnexpectedType(validation, validTypes);
}
}
// ReSharper disable once UnusedParameter.Local
private static void ThrowIfEnumerableTypeCannotBeNull(
Validation validation,
TypeValidation typeValidation)
{
var valueType = validation.ValueType;
var enumerableType = GetEnumerableGenericType(valueType);
if (enumerableType.IsValueType && (Nullable.GetUnderlyingType(enumerableType) == null))
{
ThrowParameterUnexpectedType(validation, nameof(IEnumerable), EnumerableOfAnyReferenceTypeName, EnumerableOfNullableGenericTypeName);
}
}
private static void ThrowIfAnyValidationParameterTypeDoesNotEqualEnumerableValueType(
Validation validation,
TypeValidation typeValidation)
{
var enumerableType = GetEnumerableGenericType(validation.ValueType);
foreach (var validationParameter in validation.ValidationParameters)
{
if (validationParameter.ValueType != enumerableType)
{
ThrowValidationParameterUnexpectedType(validation.ValidationName, validationParameter.ValueType, validationParameter.Name, enumerableType);
}
}
}
private static void ThrowIfAnyValidationParameterTypeDoesNotEqualValueType(
Validation validation,
TypeValidation typeValidation)
{
var valueType = validation.ValueType;
foreach (var validationParameter in validation.ValidationParameters)
{
if (validationParameter.ValueType != valueType)
{
ThrowValidationParameterUnexpectedType(validation.ValidationName, validationParameter.ValueType, validationParameter.Name, valueType);
}
}
}
private static void ThrowIfDictionaryTypeCannotBeNull(
Validation validation,
TypeValidation typeValidation)
{
var valueType = validation.ValueType;
var dictionaryValueType = GetDictionaryGenericValueType(valueType);
if (dictionaryValueType.IsValueType && (Nullable.GetUnderlyingType(dictionaryValueType) == null))
{
// Nullable<T> is a struct, not a reference type, which is why we explicitly call it out
// see: https://stackoverflow.com/a/3149180/356790
ThrowParameterUnexpectedType(validation, DictionaryTypeName, DictionaryWithValueOfAnyReferenceTypeName, DictionaryWithValueOfNullableGenericTypeName, ReadOnlyDictionaryWithValueOfAnyReferenceTypeName, ReadOnlyDictionaryWithValueOfNullableGenericTypeName);
}
}
private static void ThrowIfEnumerableTypeCannotBeNull(
Validation validation,
TypeValidation typeValidation)
{
var valueType = validation.ValueType;
var enumerableType = GetEnumerableGenericType(valueType);
if (enumerableType.IsValueType && (Nullable.GetUnderlyingType(enumerableType) == null))
{
// Nullable<T> is a struct, not a reference type, which is why we explicitly call it out
// see: https://stackoverflow.com/a/3149180/356790
ThrowParameterUnexpectedType(validation, EnumerableOfAnyReferenceTypeName, EnumerableOfNullableGenericTypeName, EnumerableWhenNotEnumerableOfAnyValueTypeName);
}
}
public static bool IsValid(TypeValidation type, object value)
{
bool isValid = false;
switch (type)
{
case TypeValidation.DIGIT:
{
isValid = (int)value > 0;
break;
}
case TypeValidation.WORD:
{
isValid = (!string.IsNullOrEmpty(value.ToString())) && (!string.IsNullOrWhiteSpace(value.ToString()));
break;
}
}
return(isValid);
}
