C# ValidationResults.AddAllResults方法代码示例

        public void CheckLink(ValidationResults results) {
            var validator = ValidationFactory.CreateValidator<ChangesetLink>();
            var linkResults = validator.Validate(Link);

            if(!linkResults.IsValid) {
                results.AddAllResults(linkResults);
            }
        }

        public void CheckProjects(ValidationResults results) {
            var validator = ValidationFactory.CreateValidatorFromAttributes(typeof(TestPublishProjectMapping),
                string.Empty);

            foreach (TestPublishProjectMapping project in Projects) {
                var projectResults = validator.Validate(project);
                
                if(!projectResults.IsValid) {
                    results.AddAllResults(projectResults);
                }
            }
        }

 public void DoValidateSave(ValidationResults results)
 {
     results.AddAllResults(
         Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<TrainingEstimate>(this.Training, "Save"));
     results.AddAllResults(
         Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<TravelEstimate>(this.Travel, "Save"));
 }

        public void DoValidateEstimates(ValidationResults results)
        {
            if (this.HasTraining)
            {
                results.AddAllResults(
                    Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<TrainingEstimate>(this.Training, "Estimates"));
                if (!this.Training.StartingDate.IsBetween(this.EventStart, this.EventEnd, true))
                {
                    results.AddResult(new ValidationResult(
                           "The start date is not valid.",
                           typeof(TrainingEstimate), "", "training start date", null));
                }
                if (!this.Training.EndingDate.IsBetween(this.EventStart, this.EventEnd, true))
                {
                    results.AddResult(new ValidationResult(
                           "The end date is not valid",
                           typeof(TrainingEstimate), "", "training start date", null));
                }
            }
            if (this.HasTravel)
            {
                results.AddAllResults(
                    Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<TravelEstimate>(this.Travel, "Estimates"));
            }

            if (this.MiscealleanousCostsComments.Length > 0 && this.MisceallaneousCosts <= 0M)
            {
                results.AddResult(new ValidationResult("General comments estimated cost is required.",
                        typeof(TravelAndTrainingRequest),
                        "", "", null));
            }
            else if (this.MisceallaneousCosts != 0M &&
                this.MiscealleanousCostsComments.Length == 0)
            {
                results.AddResult(new ValidationResult("General comments are required.",
                        typeof(TravelAndTrainingRequest),
                        "", "", null));
            }
        }

        public void CanAddValidationResultsFromCollection()
        {
            ValidationResults validationResults = new ValidationResults();
            validationResults.AddResult(new ValidationResult("existing 1", null, null, null, null));
            validationResults.AddResult(new ValidationResult("existing 2", null, null, null, null));
            ValidationResult[] newValidationResults = new ValidationResult[]
                {
                    new ValidationResult("new 1", null, null, null, null),
                    new ValidationResult("new 2", null, null, null, null),
                    new ValidationResult("new 3", null, null, null, null)
                };

            validationResults.AddAllResults(newValidationResults);

            IDictionary<string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
            Assert.AreEqual(5, resultsMapping.Count);
            Assert.IsTrue(resultsMapping.ContainsKey("existing 1"));
            Assert.IsTrue(resultsMapping.ContainsKey("existing 2"));
            Assert.IsTrue(resultsMapping.ContainsKey("new 1"));
            Assert.IsTrue(resultsMapping.ContainsKey("new 2"));
            Assert.IsTrue(resultsMapping.ContainsKey("new 3"));
        }

        /// <summary>
        /// Does the validate.
        /// </summary>
        /// <param name="objectToValidate">The object to validate.</param>
        /// <param name="currentTarget">The current target.</param>
        /// <param name="key">The key.</param>
        /// <param name="validationResults">The validation results.</param>
		protected override void DoValidate(object objectToValidate, object currentTarget, string key, ValidationResults validationResults)
		{
			Validator validator = new ValidationIntegrationHelper(this).GetValidator();

			if (validator != null)
			{
				ValidationResults results = validator.Validate(this);

				if (!results.IsValid)
				{
					validationResults.AddAllResults(results);
				}
			}
		}

        public void CheckMandatoryFields(ValidationResults results) {
            var validator = ValidationFactory.CreateValidatorFromAttributes(typeof(ClearQuestField), string.Empty);

            foreach(ClearQuestField field in MandatoryFields) {
                var fieldResults = validator.Validate(field);
                
                if(!fieldResults.IsValid) {
                    results.AddAllResults(fieldResults);
                }
            }
        }

        public void CheckPriorityMappings(ValidationResults results) {
            var validator = ValidationFactory.CreateValidator<ClearQuestPriorityMapping>();

            foreach(ClearQuestPriorityMapping mapping in PriorityMappings) {
                var mappingValidationResults = validator.Validate(mapping);

                if(!mappingValidationResults.IsValid) {
                    results.AddAllResults(mappingValidationResults);
                }
            }
        }

 public void DoValidateSubmit(ValidationResults results)
 {
     if (!this.HasFlightArrangements && !this.HasGroundArrangements && !this.HasLodgingArrangements)
         results.AddResult(new ValidationResult("At least one travel arrangement is required.",
             typeof(TravelEstimate), "", "travel arrangement", null));
     else
     {
         if (this.HasFlightArrangements)
         {
             results.AddAllResults(
                 Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<Airfare>(this.FlightArrangements, "Submit"));
         }
         if (this.HasGroundArrangements)
         {
             results.AddAllResults(
                  Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<Ground>(this.GroundArrangements, "Submit"));
         }
         if (this.HasLodgingArrangements)
         {
             results.AddAllResults(
                  Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<Lodging>(this.LodgingArrangements, "Submit"));
         }
     }
 }

        public void CheckProjectMappings(ValidationResults results)
        {
            var validator = ValidationFactory.CreateValidator<JiraProjectMapping>();

            foreach (var mapping in ProjectMappings)
            {
                var mappingValidationResults = validator.Validate(mapping);

                if (!mappingValidationResults.IsValid)
                {
                    results.AddAllResults(mappingValidationResults);
                }
            }
        }

 public void DoValidateSave(ValidationResults results)
 {
     results.AddAllResults(
             Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<Airfare>(this.FlightArrangements, "Save"));
      results.AddAllResults(
              Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<Ground>(this.GroundArrangements, "Save"));
      results.AddAllResults(
              Microsoft.Practices.EnterpriseLibrary.Validation.Validation.Validate<Lodging>(this.LodgingArrangements, "Save"));
 }

        public void CheckPriorityMappings(ValidationResults results) {
            var validator = ValidationFactory.CreateValidatorFromAttributes(typeof(QCPriorityMapping), string.Empty);

            foreach(QCPriorityMapping mapping in PriorityMappings) {
                results.AddAllResults(validator.Validate(mapping));                
            }
        }

 public void CheckConnection(ValidationResults results) {
     var validator = ValidationFactory.CreateValidatorFromAttributes(typeof(QCConnection), string.Empty);
     var defectFilterResults = validator.Validate(Connection);
     results.AddAllResults(defectFilterResults);
 }

        public void CheckDefectFilters(ValidationResults results) {
            var validator = ValidationFactory.CreateValidatorFromAttributes(typeof(QCDefectFilter), string.Empty);

            foreach(QCDefectFilter filter in DefectFilters) {
                results.AddAllResults(validator.Validate(filter));
            }
        }

        public void CheckProjects(ValidationResults results) {
            var validator = ValidationFactory.CreateValidatorFromAttributes(typeof(QCProject), string.Empty);

            foreach(QCProject project in Projects) {
                results.AddAllResults(validator.Validate(project));
            }
        }