CyberX8/Framework/ClientBase/OpenSEMI.ClientBase/DataErrorInfo.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;

namespace OpenSEMI.ClientBase
{
	public class DataErrorInfo<T> : IDataErrorInfo where T : class
	{
		private readonly T ImplementorInstance;

		private Dictionary<string, Func<T, object>> PropertyGetterMap;

		private Dictionary<string, ValidationAttribute[]> ValidatorMap;

		private bool HasInitialisedValidator;

		public string this[string propertyName]
		{
			get
			{
				if (!HasInitialisedValidator)
				{
					InitialiseValidators();
				}
				if (PropertyGetterMap.ContainsKey(propertyName))
				{
					object propertyValue = PropertyGetterMap[propertyName](ImplementorInstance);
					string[] value = Enumerable.ToArray<string>(Enumerable.Select<ValidationAttribute, string>(Enumerable.Where<ValidationAttribute>((IEnumerable<ValidationAttribute>)ValidatorMap[propertyName], (Func<ValidationAttribute, bool>)((ValidationAttribute v) => !v.IsValid(propertyValue))), (Func<ValidationAttribute, string>)((ValidationAttribute v) => v.ErrorMessage)));
					return string.Join(Environment.NewLine, value);
				}
				return string.Empty;
			}
		}

		public string Error
		{
			get
			{
				if (!HasInitialisedValidator)
				{
					InitialiseValidators();
				}
				IEnumerable<string> source = Enumerable.Select(Enumerable.Where(Enumerable.SelectMany((IEnumerable<KeyValuePair<string, ValidationAttribute[]>>)ValidatorMap, (Func<KeyValuePair<string, ValidationAttribute[]>, IEnumerable<ValidationAttribute>>)((KeyValuePair<string, ValidationAttribute[]> validator) => validator.Value), (KeyValuePair<string, ValidationAttribute[]> validator, ValidationAttribute attribute) => new
				{
					validator,
					attribute
				}), _003C_003Eh__TransparentIdentifier0 => !_003C_003Eh__TransparentIdentifier0.attribute.IsValid(PropertyGetterMap[_003C_003Eh__TransparentIdentifier0.validator.Key](ImplementorInstance))), _003C_003Eh__TransparentIdentifier0 => _003C_003Eh__TransparentIdentifier0.attribute.ErrorMessage);
				return string.Join(Environment.NewLine, Enumerable.ToArray<string>(source));
			}
		}

		public DataErrorInfo(T implementator)
		{
			ImplementorInstance = implementator;
		}

		private void InitialiseValidators()
		{
			HasInitialisedValidator = true;
			ValidatorMap = Enumerable.ToDictionary<PropertyInfo, string, ValidationAttribute[]>(Enumerable.Where<PropertyInfo>((IEnumerable<PropertyInfo>)ImplementorInstance.GetType().GetProperties(), (Func<PropertyInfo, bool>)((PropertyInfo p) => GetValidations(p).Length != 0)), (Func<PropertyInfo, string>)((PropertyInfo p) => p.Name), (Func<PropertyInfo, ValidationAttribute[]>)GetValidations);
			PropertyGetterMap = Enumerable.ToDictionary<PropertyInfo, string, Func<T, object>>(Enumerable.Where<PropertyInfo>((IEnumerable<PropertyInfo>)ImplementorInstance.GetType().GetProperties(), (Func<PropertyInfo, bool>)((PropertyInfo p) => GetValidations(p).Length != 0)), (Func<PropertyInfo, string>)((PropertyInfo p) => p.Name), (Func<PropertyInfo, Func<T, object>>)GetValueGetter);
		}

		private static ValidationAttribute[] GetValidations(PropertyInfo property)
		{
			return (ValidationAttribute[])property.GetCustomAttributes(typeof(ValidationAttribute), true);
		}

		private static Func<T, object> GetValueGetter(PropertyInfo property)
		{
			return (T viewmodel) => property.GetValue(viewmodel, null);
		}
	}
}