// 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); }