/// <summary>
        /// Actual implementation how to validate the specified object.
        /// </summary>
        /// <param name="contextParams">Additional context parameters.</param>
        /// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
        /// <param name="validationContext">The object to validate.</param>
        /// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
        protected override bool ValidateGroup(IDictionary<string, object> contextParams, IValidationErrors errors, object validationContext)
        {
            ValidationErrors tmpErrors = new ValidationErrors();
            bool valid = false;
            foreach (IValidator validator in Validators)
            {
                bool tmpValid = validator.Validate(validationContext, contextParams, tmpErrors);
                if (valid && tmpValid)
                {
                    valid = false;
                    if (this.FastValidate)
                    {
                        break;
                    }
                }
                else if (tmpValid)
                {
                    valid = true;
                }
            }

            if (!valid)
            {
                errors.MergeErrors(tmpErrors);
            }

            return valid;            
        }

        /// <summary>
        /// Gets or sets a flag specifying whether this binding is valid.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this binding evaluated without errors;
        ///     <c>false</c> otherwise.
        /// </value>
        public bool IsValid(IValidationErrors errors)
        {
            if (errors == null) return true;

            IList errorList = errors.GetErrors(ALL_BINDINGERRORS_PROVIDER);
            return (errorList == null) || (!errorList.Contains(this.ErrorMessage));
        }

        /// <summary>Constructor</summary>
        /// <param name="errors">Validation errors</param>
        public ValidationException(IValidationErrors errors)
            : base(errors.ToExceptionMessage())
        {
            Checker.ArgumentIsNull(errors, "errors");

            Errors = errors;
        }

 /// <summary>
 /// 把錯誤訊息記錄到IValidationDictionary的物件裡面
 /// </summary>
 /// <param name="validationDictionary">儲存目前Validation結果的Dictionary</param>
 /// <param name="propertyErrors">要記錄到ValidationDictionary裡面的錯誤訊息</param>
 public static void AddValidationErrors(this IValidationDictionary validationDictionary, IValidationErrors propertyErrors)
 {
     foreach (var databaseValidationError in propertyErrors.Errors)
     {
         validationDictionary.AddError(databaseValidationError.PropertyName, databaseValidationError.PropertyExceptionMessage);
     }
 }

 /// <summary>
 /// Called when associated validator is invalid.
 /// </summary>
 /// <param name="validationContext">Validation context.</param>
 /// <param name="contextParams">Additional context parameters.</param>
 /// <param name="errors">Validation errors container.</param>
 protected override void OnInvalid(object validationContext, IDictionary<string, object> contextParams, IValidationErrors errors)
 {
     ErrorMessage error = CreateErrorMessage(validationContext, contextParams);
     foreach (string provider in this.providers)
     {
         errors.AddError(provider.Trim(), error);
     }
 }

 protected void ConsumeErrors(IValidationErrors errors)
 {
     //ModelState.Clear();
     foreach (IValidationError error in errors)
     {
         ConsumeError(error);
     }
 }

        /// <summary>
        /// Binds target object to source object.
        /// </summary>
        /// <param name="source">
        ///   The source object.
        /// </param>
        /// <param name="target">
        ///   The target object.
        /// </param>
        /// <param name="validationErrors">
        ///   Validation errors collection that type conversion errors should be added to.
        /// </param>
        /// <param name="variables">
        ///   Variables that should be used during expression evaluation.
        /// </param>
        public override void BindTargetToSource(object source, object target, IValidationErrors validationErrors, IDictionary<string, object> variables)
        {
            if (variables == null)
            {
                variables = new Dictionary<string, object>();
            }
            variables["source"] = source;
            variables["target"] = target;

            sourceExpression.GetValue(null, variables);
        }

        /// <summary>
        /// Binds source object to target object.
        /// </summary>
        /// <param name="source">
        /// The source object.
        /// </param>
        /// <param name="target">
        /// The target object.
        /// </param>
        /// <param name="validationErrors">
        /// Validation errors collection that type conversion errors should be added to.
        /// </param>
        /// <param name="variables">
        /// Variables that should be used during expression evaluation.
        /// </param>
        public override void BindSourceToTarget(object source, object target, IValidationErrors validationErrors,
                                                IDictionary variables)
        {
            if (variables == null)
            {
                variables = new Hashtable();
            }
            variables["source"] = source;
            variables["target"] = target;

            targetExpression.GetValue(null, variables);
        }

 /// <summary>
 /// Marks this binding's state as invalid for this validationErrors collection. 
 /// Returns false if <paramref name="validationErrors"/> is null.
 /// </summary>
 /// <param name="validationErrors"></param>
 /// <returns>false, if validationErrors is null</returns>
 protected bool SetInvalid(IValidationErrors validationErrors)
 {
     if (validationErrors != null)
     {
         foreach (string provider in this.ErrorProviders)
         {
             validationErrors.AddError(provider, this.ErrorMessage);
         }
         return true;
     }
     return false;
 }

 /// <summary>
 /// Actual implementation how to validate the specified object.
 /// </summary>
 /// <param name="validationContext">The object to validate.</param>
 /// <param name="contextParams">Additional context parameters.</param>
 /// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
 /// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
 protected override bool ValidateGroup(IDictionary contextParams, IValidationErrors errors, object validationContext)
 {
     bool valid = true;
     foreach (IValidator validator in this.Validators)
     {
         valid = validator.Validate(validationContext, contextParams, errors) && valid;
         if (!valid && this.FastValidate)
         {
             break;
         }
     }
     return valid;
 }

 /// <summary>
 /// Executes the action.
 /// </summary>
 /// <param name="isValid">Whether associated validator is valid or not.</param>
 /// <param name="validationContext">Validation context.</param>
 /// <param name="contextParams">Additional context parameters.</param>
 /// <param name="errors">Validation errors container.</param>
 public virtual void Execute(bool isValid, object validationContext, IDictionary contextParams, IValidationErrors errors)
 {
     if (EvaluateWhen(validationContext, contextParams))
     {
         if (isValid)
         {
             OnValid(validationContext, contextParams, errors);
         }
         else
         {
             OnInvalid(validationContext, contextParams, errors);
         }
     }
 }

 /// <summary>
 /// Binds source object to target object.
 /// </summary>
 /// <param name="source">
 ///   The source object.
 /// </param>
 /// <param name="target">
 ///   The target object.
 /// </param>
 /// <param name="validationErrors">
 ///   Validation errors collection that type conversion errors should be added to.
 /// </param>
 /// <param name="variables">
 ///   Variables that should be used during expression evaluation.
 /// </param>
 public override void BindSourceToTarget(object source, object target, IValidationErrors validationErrors, IDictionary<string, object> variables)
 {
     if (this.IsValid(validationErrors)
         && (this.Direction == BindingDirection.Bidirectional || this.Direction == BindingDirection.SourceToTarget))
     {
         try
         {
             DoBindSourceToTarget(source, target, variables);
         }
         catch (Exception)
         {
             if (!SetInvalid(validationErrors)) throw;
         }
     }
 }

        /// <summary>
        /// Validates the specified object.
        /// </summary>
        /// <param name="contextParams">Additional context parameters.</param>
        /// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
        /// <param name="validationContext">The object to validate.</param>
        /// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
        protected override bool ValidateGroup(IDictionary<string, object> contextParams, IValidationErrors errors, object validationContext)
        {
            // capture errors in separate collection to only add them to the error collector in case of errors
            ValidationErrors tmpErrors = new ValidationErrors();
            bool valid = false;
            foreach (IValidator validator in Validators)
            {
                valid = validator.Validate(validationContext, contextParams, tmpErrors) || valid;
                if (valid && FastValidate)
                {
                    break;
                }
            }

            if (!valid)
            {
                errors.MergeErrors(tmpErrors);
            }
            return valid;
        }

 /// <summary>
 /// Called when associated validator is invalid.
 /// </summary>
 /// <param name="validationContext">Validation context.</param>
 /// <param name="contextParams">Additional context parameters.</param>
 /// <param name="errors">Validation errors container.</param>
 protected override void OnInvalid(object validationContext, IDictionary<string, object> contextParams, IValidationErrors errors)
 {
     if (throwsExpression != null)
     {
         object o = null;
         try
         {
             o = throwsExpression.GetValue(null, contextParams);
         }
         catch (Exception e)
         {
             log.Error("Was not able to evaluate action expression [" + throwsExpression + "]", e);
         }
         Exception exception = o as Exception;
         if (exception != null)
         {
             throw exception;
         }                
     }          
     throw new ValidationException(errors);
 }

        /// <summary>
        /// Merges another instance of <see cref="ValidationErrors"/> into this one.
        /// </summary>
        /// <remarks>
        /// <p>
        /// If the supplied <paramref name="errorsToMerge"/> is <see lang="null"/>,
        /// then no errors will be added to this instance, and this method will
        /// (silently) return.
        /// </p>
        /// </remarks>
        /// <param name="errorsToMerge">
        /// The validation errors to merge; can be <see lang="null"/>.
        /// </param>
        public void MergeErrors(IValidationErrors errorsToMerge)
        {
            if (errorsToMerge != null)
            {
                foreach(string provider in errorsToMerge.Providers)
                {
                    List<ErrorMessage> errList;
                    List<ErrorMessage> other = new List<ErrorMessage>(errorsToMerge.GetErrors(provider));
                    if (!errorMap.TryGetValue(provider, out errList))
                    {
                        this.errorMap[provider] = other;
                    }
                    else
                    {
                        errList.AddRange(other);
                    }
                }
//                foreach (DictionaryEntry errorEntry in errorsToMerge.errorMap)
//                {
//                    ArrayList errList = (ArrayList) this.errorMap[errorEntry.Key];
//                    if (errList == null)
//                    {
//                        this.errorMap[errorEntry.Key] = errorEntry.Value;
//                    }
//                    else
//                    {
//                        errList.AddRange((IList) errorEntry.Value);
//                    }
//                }
            }
        }

 /// <summary>
 /// Binds target object to source object.
 /// </summary>
 /// <param name="source">
 /// The source object.
 /// </param>
 /// <param name="target">
 /// The target object.
 /// </param>
 /// <param name="validationErrors">
 /// Validation errors collection that type conversion errors should be added to.
 /// </param>
 /// <param name="variables">
 /// Variables that should be used during expression evaluation.
 /// </param>
 public abstract void BindTargetToSource(object source, object target, IValidationErrors validationErrors, IDictionary variables);

 /// <summary>
 /// Actual implementation how to validate the specified object.
 /// </summary>
 /// <param name="validationContext">The object to validate.</param>
 /// <param name="contextParams">Additional context parameters.</param>
 /// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
 /// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
 protected abstract bool ValidateGroup(IDictionary contextParams, IValidationErrors errors, object validationContext);

        /// <summary>
        /// Validates the specified object.
        /// </summary>
        /// <param name="validationContext">The object to validate.</param>
        /// <param name="contextParams">Additional context parameters.</param>
        /// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
        /// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
        public bool Validate(object validationContext, IDictionary contextParams, IValidationErrors errors)
        {
            bool valid = true;

            if (When == null || 
                Convert.ToBoolean(When.GetValue(validationContext, contextParams)))
            {
                if (Context != null)
                {
                    validationContext = Context.GetValue(validationContext, contextParams);
                }
                if (validator == null)
                {
                    validator = (IValidator)objectFactory.GetObject(Name);
                }
                valid = validator.Validate(validationContext, contextParams, errors);
            }

            return valid;
        }

        /// <summary>
        /// Actual implementation how to validate the specified object.
        /// </summary>
        /// <param name="validationContext">The object to validate.</param>
        /// <param name="contextParams">Additional context parameters.</param>
        /// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
        /// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
        protected override bool ValidateGroup(IDictionary contextParams, IValidationErrors errors, object validationContext)
        {
            bool valid = true;
            IEnumerable collectionToValidate = (validationContext is IDictionary
                ? ((IDictionary) validationContext).Values
                : (IEnumerable) validationContext);

            // decide whether to pass new validation errors collection
            //(and discard error messages returned by the item validators)
            // OR to pass validation errors collection that was passed to this method
            //(and collect all error messages returned by the item validators)
            IValidationErrors err = (includeElementErrors)? errors : new ValidationErrors();

            foreach (object objectToValidate in collectionToValidate)
            {
                foreach (IValidator validator in this.Validators)
                {
                    valid = validator.Validate(objectToValidate, contextParams, err) && valid;
                    if (!valid && this.FastValidate)
                    {
                        break;
                    }
                }

                if (!valid && this.FastValidate)
                {
                    break;
                }
            }
            return valid;
        }

 /// <summary>
 /// Processes the error messages.
 /// </summary>
 /// <param name="isValid">Whether validator is valid or not.</param>
 /// <param name="validationContext">Validation context.</param>
 /// <param name="contextParams">Additional context parameters.</param>
 /// <param name="errors">Validation errors container.</param>
 protected void ProcessActions(bool isValid, object validationContext, IDictionary contextParams, IValidationErrors errors)
 {
     if (actions != null && actions.Count > 0)
     {
         foreach (IValidationAction action in actions)
         {
             action.Execute(isValid, validationContext, contextParams, errors);
         }
     }
 }