public static void ThrowExceptionWhenIsNotValidIdentifier(string paramName, string value)
{
Validators.EnsureValidParamName(paramName);
if (!CodeGenerator.IsValidLanguageIndependentIdentifier(value))
{
throw new ArgumentException(StringExtensions.StringFormat("{0} no es un identificador válido", (object)paramName), paramName);
}
}
public static void ThrowExceptionWhenIsNullOrEmptyList(string paramName, IEnumerable list)
{
Validators.EnsureValidParamName(paramName);
if (list == null || Enumerable.Count <object>(Enumerable.Cast <object>(list)) == 0)
{
throw new ArgumentException(StringExtensions.StringFormat("La lista {0} no puede estar vacía", (object)paramName), paramName);
}
}
public static void ThrowExceptionWhenIsNullOrWhiteSpace(string paramName, string value)
{
Validators.EnsureValidParamName(paramName);
if (string.IsNullOrWhiteSpace(value))
{
throw new ArgumentNullException(StringExtensions.StringFormat("{0} no puede ser nulo, vacío o solo espacios", (object)paramName), paramName);
}
}
public static void ThrowExceptionWhenIsNotHexString(string paramName, string value)
{
Validators.EnsureValidParamName(paramName);
if (value != null && Enumerable.Any <char>((IEnumerable <char>)value, (Func <char, bool>)(c => !Uri.IsHexDigit(c))))
{
throw new ArgumentNullException(StringExtensions.StringFormat("{0} tiene que ser una cadena hexadecimal", (object)paramName), paramName);
}
}
public static void ThrowExceptionWhenIsTooLong(string paramName, string value, int maxLength)
{
Validators.EnsureValidParamName(paramName);
if (value != null && value.Length > maxLength)
{
throw new ArgumentException(StringExtensions.StringFormat("El valor de '{0}' es demasiado largo (máximo {1})", (object)paramName, (object)maxLength), paramName);
}
}
public static void ThrowExceptionWhenIsNotEquals(string paramName, object value, object expectedValue)
{
Validators.EnsureValidParamName(paramName);
if (value == null && expectedValue == null || value != null && !value.Equals(expectedValue))
{
throw new ArgumentException(StringExtensions.StringFormat("{0} no tiene un valor correcto ({1})", (object)paramName, expectedValue), paramName);
}
}
public static void ThrowExceptionWhenIsNull(string paramName, object value)
{
Validators.EnsureValidParamName(paramName);
if (value == null)
{
throw new ArgumentNullException(StringExtensions.StringFormat("{0} no puede ser nulo", (object)paramName), paramName);
}
}
public static void ThrowExceptionWhenNotInEnum(string paramName, object value, Type enumType)
{
Validators.EnsureValidParamName(paramName);
Validators.ThrowExceptionWhenIsNull("enumType", (object)enumType);
Type enumType1 = enumType;
bool flag = false;
if (enumType.IsGenericType)
{
if (!enumType.Assembly.FullName.Equals(typeof(Nullable <>).Assembly.FullName) || !enumType.Namespace.Equals(typeof(Nullable <>).Namespace) || !enumType.Name.Equals(typeof(Nullable <>).Name))
{
throw new ArgumentException("enumType debe ser una enumeración", "enumType");
}
flag = true;
enumType1 = Nullable.GetUnderlyingType(enumType);
}
if (!enumType1.IsEnum)
{
throw new ArgumentException("enumType debe ser una enumeración", "enumType");
}
if (!flag && value == null)
{
throw new ArgumentException("El valor de '{0}' no puedo ser nulo si el tipo no es nulable", paramName);
}
if (!Enumerable.Any <FlagsAttribute>(Enumerable.OfType <FlagsAttribute>((IEnumerable)enumType1.GetCustomAttributes(false))))
{
if (value != null && !Enum.IsDefined(enumType1, value))
{
throw new ArgumentException("El valor de '{0}' no es un valor posible", paramName);
}
}
else
{
IEnumerable <long> enumerable = Enumerable.Select <object, long>(Enumerable.Cast <object>((IEnumerable)Enum.GetValues(enumType1)), (Func <object, long>)(x => (long)Convert.ChangeType(x, typeof(long))));
long num1 = 0;
long num2 = (long)Convert.ChangeType(value, typeof(long));
foreach (long num3 in enumerable)
{
if ((num3 & num2) == num3)
{
num1 += num3;
}
}
if (num1 != num2)
{
throw new ArgumentException("El valor de '{0}' no es un valor posible", paramName);
}
}
}
