通用数据验证框架

 

     /// <summary>
    /// DataType Validate Interface
    /// </summary>
    public interface IProcessValidate
    {
        void DoWork(string data,int min,int max,bool allownull);
    }

 

    /// <summary>
    /// Concrete DataType Validate Class
    /// </summary>
    public class IntProcessValidate:IProcessValidate
    {
        #region IProcessValidate Members
        public IntProcessValidate()
        {
        }
        public void DoWork(string data, int min, int max, bool allownull)
        {
            bool isInt;
            int dataInt;
            if (allownull)
                if (String.IsNullOrEmpty(data))
                    throw new Exception("Can't be null");
            isInt = Int32.TryParse(data, out dataInt);
            if (!isInt)
                throw new Exception(data + " should be Integer");

            if (dataInt < min || dataInt > max)
                throw new Exception("Input value is not in right range.(" + min.ToString() + "--" + max.ToString() + ")");
        }

        #endregion
    }

 

    /// <summary>
    /// access to visit a control's validation information
    /// </summary>
    public interface IValidateControl
    {
        bool AllowNull { get; }
        System.Web.UI.Control Validatecontrol { get; }
        string ValidateDateType { get; }
    }
    public interface IAdvancedValidateControl : IValidateControl
    {
        int MinValue { get; }
        int MaxValue { get; }
    }
    public interface IBaseValidateData
    {
        string ValidateDataField { get; }
        string ValidateDateType { get; }
        bool AllowNull { get; }
        int MinValue { get; }
        int MaxValue { get; }
    }

 

 

    /// <summary>
    /// depict a blueprint that a control's datatype,value and so on be validated
    /// </summary>
    public class ValidateData : IValidateControl
    {
        private Control _validatacontrol;
        private string _validateDataType;
        private bool _allowNull;
        public ValidateData(Control validatecontrol, string validateDataType, bool allowNull)
        {
            _validatacontrol = validatecontrol;
            _validateDataType = validateDataType;
            _allowNull = allowNull;
        }
        public Control Validatecontrol
        {
            get { return _validatacontrol; }        
        }
        public string ValidateDateType
        {
            get { return _validateDataType; }
        }
        public bool AllowNull
        {
            get { return _allowNull; }
        }
    }
    public class SpecialValidateData : IAdvancedValidateControl
    {
        private Control _validatecontrol;
        private string _validateDataType;
        private bool _allowNull;
        private int _minValue;
        private int _maxValue;
        public SpecialValidateData(Control validatecontrol, string validateDateType,int minValue,int maxValue, bool allowNull)
        {
            _validatecontrol = validatecontrol;
            _validateDataType = validateDateType;
            _allowNull = allowNull;
            _minValue = minValue;
            _maxValue = maxValue;

        }

        #region ISpecialValidateData Members

        public int MinValue
        {
            get { return _minValue; }
        }

        public int MaxValue
        {
            get { return _maxValue; }
        }

        #endregion

        #region IValidateData Members
        public Control Validatecontrol
        {
            get { return _validatecontrol; }
        }
        public string ValidateDateType
        {
            get { return _validateDataType; }
        }
        public bool AllowNull
        {
            get { return _allowNull; }
        }

        #endregion
    }
    public class BaseValidateData : IBaseValidateData
    {
        private string _validateDataField;
        private string _validateDateType;
        private bool _allowNull;
        private int _minValue;
        private int _maxValue;

        public BaseValidateData(string validateDataField, string validateDateType, int minValue, int maxValue, bool allowNull)
        {
            _validateDataField = validateDataField;
            _validateDateType = validateDateType;
            _allowNull = allowNull;
            _minValue = minValue;
            _maxValue = maxValue;

        }
        #region IBaseValidateData Members

        public string ValidateDataField
        {
            get { return _validateDataField; }
        }

        public string ValidateDateType
        {
            get { return _validateDateType; }
        }

        public bool AllowNull
        {
            get { return _allowNull; }
        }

        public int MinValue
        {
            get { return _minValue; }
        }

        public int MaxValue
        {
            get { return _maxValue; }
        }

        #endregion
    }

    //T:IValidateData or ISpecialValidateData
    public class ValidateDataCollection<T>
    {
        private List<T> _dataCollection;

        public ValidateDataCollection()
        {
            _dataCollection = new List<T>();
        }
        public ValidateDataCollection(List<T> dataCollection)
        {
            _dataCollection = dataCollection;
        }
        public void AddValidateData(T validateData)
        {
            _dataCollection.Add(validateData);
        }
        public void RemoveValidateData(T validateData)
        {
            _dataCollection.Remove(validateData);
        }
        public List<T> DataCollection
        {
            get { return _dataCollection; }
        }
    }

 

 

    /// <summary>
    /// Class Factory:Create Concrete DataType Validate Class
    /// </summary>
    public class ValidateFactory
    {
        private static  ValidateFactory instance=new ValidateFactory();
        private ValidateFactory()
        {
        }
        public static ValidateFactory GetInstance()
        {
            if (instance == null)
                return new ValidateFactory();
            else return instance;
        }
        public IProcessValidate CreateConcreteDataType(string dataType)
        {
            switch (dataType)
            {
                case "Int":
                    return new IntProcessValidate();
                case "Decimal":
                    return new DecimalProcessValidate();
                case "DateTime":
                    return new DateTimeProcessValidate();
   
                case "String":
                    return new StringProcessValidate();
                  
                default:
                    throw new Exception("No such DataType");                 
            }
        }
    }

 

 

    public class ProcessValidateStorage
    {
        private static ProcessValidateStorage instance = new ProcessValidateStorage();
        //keep ProcessValidate object to avoid create so many validate objects
        private static Hashtable storeProcessValidate = new Hashtable();

        private ProcessValidateStorage()
        {
        }
        public static ProcessValidateStorage GetInstance()
        {
            if (instance == null)
                return new ProcessValidateStorage();
            else return instance;
        }
        public IProcessValidate GetProcessValidate(string dataType)
        {
            IProcessValidate intProcessValidate;
            if (storeProcessValidate.Contains(dataType))
            {
                intProcessValidate = (IProcessValidate)storeProcessValidate[dataType];
            }
            else
            {
                intProcessValidate = ValidateFactory.GetInstance().CreateConcreteDataType(dataType);
                storeProcessValidate.Add(dataType, intProcessValidate);
            }
            return intProcessValidate;
        }
    }

 

    public static class ValidateControl
    {
       
        #region For Controls' Collection Validate
        public static void ValidateControlCollection(ValidateDataCollection<IAdvancedValidateControl> validateCollection)
        {
            foreach (IAdvancedValidateControl process in validateCollection.DataCollection)
            {
                if (process.Validatecontrol is TextBox)
                    ValidateTextBox((TextBox)process.Validatecontrol, process.ValidateDateType, process.MinValue, process.MaxValue, process.AllowNull);
            }
        }
        public static void ValidateControlCollection(ValidateDataCollection<IValidateControl> validateCollection)
        {
            foreach (IValidateControl process in validateCollection.DataCollection)
            {
                if (process.Validatecontrol is TextBox)
                    ValidateTextBox((TextBox)process.Validatecontrol, process.ValidateDateType, Int32.MinValue, Int32.MaxValue, process.AllowNull);
            }
        }
        #endregion
        //For TextBox Validate
        public static void ValidateTextBox(TextBox textBox, string dataType, int minValue, int maxValue, bool isAllowNull)
        {
            IProcessValidate process = ProcessValidateStorage.GetInstance().GetProcessValidate(dataType);
            process.DoWork(textBox.Text, minValue, maxValue, isAllowNull);
        }

        //Example:How to use it to validate controls
        //TEGD.Utility.Validate.ValidateDataCollection<TEGD.Utility.Validate.IBaseValidateData> validateDataCollection = new TEGD.Utility.Validate.ValidateDataCollection<TEGD.Utility.Validate.IBaseValidateData>();
        //validateDataCollection.AddValidateData(new TEGD.Utility.Validate.BaseValidateData("IsAvailable", "String", 0, 1, true));
        //validateDataCollection.AddValidateData(new TEGD.Utility.Validate.BaseValidateData("AvailableIn", "DateTime", 0, 100000000, true));
        //validateDataCollection.AddValidateData(new TEGD.Utility.Validate.BaseValidateData("Min", "Decimal", 0, 100000000, true));
        //validateDataCollection.AddValidateData(new TEGD.Utility.Validate.BaseValidateData("Max", "Decimal", 0, 100000000, true));
        //validateDataCollection.AddValidateData(new TEGD.Utility.Validate.BaseValidateData("SAPStock", "Decimal", 0, 100000000, true));
        //TEGD.Utility.Validate.ValidateControl.ValidateDetailViewInserting(validateDataCollection,e);
        #region For Detail and GridView 's Validate
        public static void ValidateDetailViewInserting(ValidateDataCollection<IBaseValidateData> dataCollection,DetailsViewInsertEventArgs e)
        {
            foreach (IBaseValidateData validate in dataCollection.DataCollection)
            {
                IProcessValidate process = ProcessValidateStorage.GetInstance().GetProcessValidate(validate.ValidateDateType);
                //e.Values[validate.ValidateDataField] may be null,how to deal with it.
                string data = e.Values[validate.ValidateDataField] == null ? String.Empty : e.Values[validate.ValidateDataField].ToString();
                process.DoWork(data, validate.MinValue, validate.MaxValue, validate.AllowNull);
            }
        }        
        public static void ValidateGridViewUpdating(ValidateDataCollection<IBaseValidateData> dataCollection,GridViewUpdateEventArgs e)
        {
            foreach (IBaseValidateData validate in dataCollection.DataCollection)
            {
                IProcessValidate process = ProcessValidateStorage.GetInstance().GetProcessValidate(validate.ValidateDateType);
                string data=e.NewValues[validate.ValidateDataField]==null?String.Empty:e.NewValues[validate.ValidateDataField].ToString();
                process.DoWork(data, validate.MinValue, validate.MaxValue, validate.AllowNull);
            }
        }
        #endregion

    }