Пример #1
0
		public override bool IsValid(ValidationContext context)
		{
			if (context.IsNull(context))
				return true;

			Match match = Validator.Match(context.Value.ToString());

			return match.Success && match.Value == context.Value.ToString();
		}
Пример #2
0
		private static bool IsNullInternal(ValidationContext context)
		{
			if (context.Value == null)
				return true;

			if (context.NullValue is DBNull)
				return false;

			return context.NullValue.Equals(context.Value);
		}
		public override bool IsValid(ValidationContext context)
		{
			if (context.IsNull(context))
				return true;

			DateTime contextValue = Convert.ToDateTime(context.Value);
			DateTime testValue    = (DateTime)GetValue(context);

			return testValue > contextValue || !IsExclusive && testValue == contextValue;
		}
Пример #4
0
		public static bool IsValid(ValidationContext context, string fieldName)
		{
			ValidatorBaseAttribute[] attrs = null;
			object                   value = null;

#if !SILVERLIGHT

			if (context.PropertyDescriptor != null)
			{
				value = context.PropertyDescriptor.GetValue(context.Object);

				List<ValidatorBaseAttribute> list = null;

				foreach (object o in context.PropertyDescriptor.Attributes)
				{
					if (o is ValidatorBaseAttribute)
					{
						if (list == null)
							list = new List<ValidatorBaseAttribute>();

						list.Add((ValidatorBaseAttribute)o);
					}
				}

				if (list != null)
					attrs = list.ToArray();
			}
			else

#endif

			{
				context.MemberAccessor = context.TypeAccessor[fieldName];

				if (context.MemberAccessor != null)
				{
					value = context.MemberAccessor.GetValue(context.Object);
					attrs = context.MemberAccessor.GetAttributes<ValidatorBaseAttribute>();
				}
			}

			if (attrs != null)
			{
				context.Value = value;

				for (int i = 0; i < attrs.Length; i++)
				{
					if (!attrs[i].IsValid(context))
						return false;
				}
			}

			return true;
		}
Пример #5
0
		public static ValidationContext InitContext(
			ValidationContext  context,
			object             obj,
			PropertyDescriptor pd,
			ValidationContext.IsNullHandler isNull)
		{
			if (context == null)
				context = new ValidationContext();

			context.Object = obj;
			context.IsNull = isNull ?? new ValidationContext.IsNullHandler(IsNullInternal);
			context.PropertyDescriptor = pd;

			return context;
		}
Пример #6
0
		public static void Validate(ValidationContext context)
		{
			foreach (MemberAccessor ma in context.TypeAccessor)
			{
				ValidatorBaseAttribute[] attrs = ma.GetAttributes<ValidatorBaseAttribute>();

				if (attrs == null)
					continue;

				context.MemberAccessor = ma;
				context.Value          = ma.GetValue(context.Object);

				for (int i = 0; i < attrs.Length; i++)
				{
					ValidatorBaseAttribute attr = attrs[i];
					if (attr.IsValid(context) == false)
						throw new ValidationException(attr.GetErrorMessage(context));
				}
			}
		}
		protected virtual string GetPropertyFriendlyName(ValidationContext context)
		{
			MemberInfo mi        = context.MemberInfo;
			string     className = mi.DeclaringType.Name;
			string     fieldName = mi.Name;

			// Get class name.
			//
			object[] attrs = mi.DeclaringType.GetCustomAttributes(typeof(FriendlyNameAttribute), true);

			if (attrs.Length > 0)
				className = ((FriendlyNameAttribute)attrs[0]).Name;
			else
			{
				attrs = mi.DeclaringType.GetCustomAttributes(typeof(DisplayNameAttribute), true);

				if (attrs.Length > 0)
					className = ((DisplayNameAttribute)attrs[0]).DisplayName;
			}

			// Get field name.
			//
			attrs = mi.GetCustomAttributes(typeof(FriendlyNameAttribute), true);

			if (attrs.Length > 0)
				fieldName = ((FriendlyNameAttribute)attrs[0]).Name;
			else
			{
				attrs = mi.GetCustomAttributes(typeof(DisplayNameAttribute), true);

				if (attrs.Length > 0)
					fieldName = ((DisplayNameAttribute)attrs[0]).DisplayName;
			}

			return string.IsNullOrEmpty(className)? fieldName: className + "." + fieldName;
		}
		public abstract bool IsValid(ValidationContext context);
Пример #9
0
		public static void Validate(object obj, ValidationContext.IsNullHandler isNull)
		{
			Validate(InitContext(null, obj, null, isNull));
		}
Пример #10
0
		public static string[] GetErrorMessages(object obj, PropertyDescriptor pd, ValidationContext.IsNullHandler isNull)
		{
			return GetErrorMessages(InitContext(null, obj, pd, isNull), pd.Name);
		}
Пример #11
0
		public static string[] GetErrorMessages(
			object obj, string fieldName, ValidationContext.IsNullHandler isNull)
		{
			return GetErrorMessages(InitContext(null, obj, null, isNull), fieldName);
		}
Пример #12
0
		public static string[] GetErrorMessages(ValidationContext context, string fieldName)
		{
			context.MemberAccessor = context.TypeAccessor[fieldName];

			if (context.MemberAccessor != null)
			{
				List<string>          messages = new List<string>();
				ValidatorBaseAttribute[] attrs = context.MemberAccessor.GetAttributes<ValidatorBaseAttribute>();

				if (attrs != null)
				{
					context.Value = context.MemberAccessor.GetValue(context.Object);

					for (int i = 0; i < attrs.Length; i++)
						messages.Add(attrs[i].GetErrorMessage(context));

					return messages.ToArray();
				}
			}

			return new string[0];
		}
Пример #13
0
		public static bool IsValid(object obj, PropertyDescriptor pd, ValidationContext.IsNullHandler isNull)
		{
			return IsValid(InitContext(null, obj, pd, isNull), pd.Name);
		}
Пример #14
0
		public override bool IsValid(ValidationContext context)
		{
			return context.IsNull(context) || context.Value.ToString().Length <= _value;
		}
		public virtual string GetErrorMessage(ValidationContext context)
		{
			return string.Format(ErrorMessage, GetPropertyFriendlyName(context));
		}
Пример #16
0
		public override bool IsValid(ValidationContext context)
		{
			if (context.IsNull(context))
				return true;

			object contextValue = context.Value;
			object testValue    = GetValue(context);

			if (contextValue is Int32)
			{
				Int32 tv = Convert.ToInt32(testValue);
				return tv > (Int32)contextValue || !IsExclusive && tv == (Int32)contextValue;
			}

			if (contextValue is decimal)
			{
				decimal tv = Convert.ToDecimal(testValue);
				return tv > (decimal)contextValue || !IsExclusive && tv == (decimal)contextValue;
			}

			if (contextValue is double)
			{
				double tv = Convert.ToDouble(testValue);
				return tv > (double)contextValue || !IsExclusive && tv == (double)contextValue;
			}

			if (contextValue is float)
			{
				float tv = Convert.ToSingle(testValue);
				return tv > (float)contextValue || !IsExclusive && tv == (float)contextValue;
			}

			if (contextValue is byte)
			{
				byte tv = Convert.ToByte(testValue);
				return tv > (byte)contextValue || !IsExclusive && tv == (byte)contextValue;
			}

			if (contextValue is char)
			{
				char tv = Convert.ToChar(testValue);
				return tv > (char)contextValue || !IsExclusive && tv == (char)contextValue;
			}

			if (contextValue is Int16)
			{
				Int16 tv = Convert.ToInt16(testValue);
				return tv > (Int16)contextValue || !IsExclusive && tv == (Int16)contextValue;
			}

			if (contextValue is sbyte)
			{
				sbyte tv = Convert.ToSByte(testValue);
				return tv > (sbyte)contextValue || !IsExclusive && tv == (sbyte)contextValue;
			}

			if (contextValue is UInt16)
			{
				UInt16 tv = Convert.ToUInt16(testValue);
				return tv > (UInt16)contextValue || !IsExclusive && tv == (UInt16)contextValue;
			}

			if (contextValue is UInt32)
			{
				UInt32 tv = Convert.ToUInt32(testValue);
				return tv > (UInt32)contextValue || !IsExclusive && tv == (UInt32)contextValue;
			}

			if (contextValue is Int64)
			{
				Int64 tv = Convert.ToInt64(testValue);
				return tv > (Int64)contextValue || !IsExclusive && tv == (Int64)contextValue;
			}

			if (contextValue is UInt64)
			{
				UInt64 tv = Convert.ToUInt64(testValue);
				return tv > (UInt64)contextValue || !IsExclusive && tv == (UInt64)contextValue;
			}

			return true;
		}
Пример #17
0
		public  virtual  object GetValue(ValidationContext context)
		{
			return _value;
		}
Пример #18
0
		public override string GetErrorMessage(ValidationContext context)
		{
			return string.Format(ErrorMessage,
				GetPropertyFriendlyName(context),
				GetValue(context),
				IsExclusive? " exclusive": string.Empty);
		}
Пример #19
0
		public override string GetErrorMessage(ValidationContext context)
		{
			return string.Format(ErrorMessage, GetPropertyFriendlyName(context), Value);
		}
Пример #20
0
		public override bool IsValid(ValidationContext context)
		{
			return context.IsNull(context) == false;
		}
Пример #21
0
		public static bool IsValid(object obj, string fieldName, ValidationContext.IsNullHandler isNull)
		{
			return IsValid(InitContext(null, obj, null, isNull), fieldName);
		}