C# ValidatorEngine.Configure方法代码示例

 private static ValidatorEngine GetValidatorEngine()
 {
     var cfg = GetNhvConfiguration();
       var validatorEngine = new ValidatorEngine();
       validatorEngine.Configure(cfg);
       return validatorEngine;
 }

        public void Configure(IWindsorContainer container)
        {
            var ve = new ValidatorEngine();

            container.Register(Component.For<IEntityValidator>()
                                   .ImplementedBy<EntityValidator>());

            container.Register(Component.For<ValidatorEngine>()
                                   .Instance(ve)
                                   .LifeStyle.Singleton);

            //Register the service for ISharedEngineProvider
            container.Register(Component.For<ISharedEngineProvider>()
                                   .ImplementedBy<NHVSharedEngineProvider>());

            //Assign the shared engine provider for NHV.
            Environment.SharedEngineProvider =
                container.Resolve<ISharedEngineProvider>();

            //Configure validation framework fluently
            var configure = new FluentConfiguration();

            configure.Register(typeof (WorkerValidationDefenition).Assembly.ValidationDefinitions())
                .SetDefaultValidatorMode(ValidatorMode.OverrideAttributeWithExternal)
                .AddEntityTypeInspector<NHVTypeInspector>()
                .IntegrateWithNHibernate.ApplyingDDLConstraints().And.RegisteringListeners();

            ve.Configure(configure);
        }

        ///<remarks>
        /// The output of this function should be either put into your IoC container or cached somewhere to prevent
        /// re-reading of the config files.
        ///</remarks>
        public static ValidatorEngine CreateValidationEngine()
        {
            var validator = new ValidatorEngine();
            validator.Configure();

            return validator;
        }

        public void ValidateWithMultipleConditions()
        {
            var configure = new FluentConfiguration();

            var validationDef = new ValidationDef<EntityWithString>();
            validationDef.Define(e => e.Name)
                .Satisfy(name => name != null && name.StartsWith("ab")).WithMessage("Name should start with 'ab'")
                .And
                .Satisfy(name => name != null && name.EndsWith("zz")).WithMessage("Name should end with 'zz'");

            configure.Register(validationDef).SetDefaultValidatorMode(ValidatorMode.UseExternal);
            var ve = new ValidatorEngine();

            ve.Configure(configure);

            Assert.That(ve.IsValid(new EntityWithString { Name = "abczz" }));
            Assert.That(!ve.IsValid(new EntityWithString { Name = "bc" }));
            var iv = ve.Validate(new EntityWithString {Name = "abc"});
            Assert.That(iv.Length, Is.EqualTo(1));
            Assert.That(iv.Select(i => i.Message).First(), Is.EqualTo("Name should end with 'zz'"));

            iv = ve.Validate(new EntityWithString { Name = "zz" });
            Assert.That(iv.Length, Is.EqualTo(1));
            Assert.That(iv.Select(i => i.Message).First(), Is.EqualTo("Name should start with 'ab'"));

            iv = ve.Validate(new EntityWithString { Name = "bc" });
            Assert.That(iv.Length, Is.EqualTo(2));
            var messages = iv.Select(i => i.Message);
            Assert.That(messages, Has.Member("Name should start with 'ab'") & Has.Member("Name should end with 'zz'"));
        }

 public void CreateEngine()
 {
     var conf = new XmlConfiguration();
     conf.Properties[Environment.ValidatorMode] = "UseExternal";
     conf.Mappings.Add(new MappingConfiguration("NHibernate.Validator.Tests", "NHibernate.Validator.Tests.Engine.Tagging.EntityXml.nhv.xml"));
     ve = new ValidatorEngine();
     ve.Configure(conf);
 }

        public void when_validate_customer_with_invalid_name_and_email_should_return_two_invalid_values()
        {
            var validatorEngine = new ValidatorEngine();
            var notValidCustomer = GetNotValidCustomer();
            validatorEngine.Configure();

            validatorEngine.Validate(notValidCustomer).Should().Have.Count.EqualTo(2);
        }

        public void CreateValidatorEngine()
        {
            var configure = new FluentConfiguration();
            configure.Register(new[] {typeof (UserValidation), typeof (GroupValidation)})
                .SetDefaultValidatorMode(ValidatorMode.UseExternal);
            validatorEngine = new ValidatorEngine();

            validatorEngine.Configure(configure);
        }

        private static void ConfigureNHibernateValidator(Configuration configuration)
        {
            INHVConfiguration nhvc = (INHVConfiguration)new NHibernate.Validator.Cfg.Loquacious.FluentConfiguration()
                .SetDefaultValidatorMode(ValidatorMode.UseAttribute);

            var validator = new ValidatorEngine();
            validator.Configure(nhvc);
            configuration.Initialize(validator);
        }

 public ValidatorEngine GetValidatorEngine()
 {
     var vtor = new ValidatorEngine();
     var cfg = new XmlConfiguration();
     cfg.Properties[Environment.ValidatorMode] = "UseExternal";
     string an = Assembly.GetExecutingAssembly().FullName;
     cfg.Mappings.Add(new MappingConfiguration(an, "NHibernate.Validator.Tests.Specifics.NHV29.Mappings.nhv.xml"));
     vtor.Configure(cfg);
     return vtor;
 }

        public void DelegatedValidate_WithoutMessageNotThrow()
        {
            var configure = new FluentConfiguration();
            configure.Register(new[] { typeof(RangeDefWithoutCustomMessage) })
                .SetDefaultValidatorMode(ValidatorMode.UseExternal);
            var ve = new ValidatorEngine();

            ve.Configure(configure);
            ActionAssert.NotThrow(()=>ve.IsValid(new Range { Start = 1, End = 4 }));
        }

 public virtual ValidatorEngine GetValidatorEngine()
 {
     var ve = new ValidatorEngine();
     var cfg = new XmlConfiguration();
     cfg.Properties[Environment.ValidatorMode] = "UseAttribute";
     cfg.Properties[Environment.ConstraintValidatorFactoryClass] =
         typeof (TestConstraintValidatorFactory).AssemblyQualifiedName;
     ve.Configure(cfg);
     return ve;
 }

 protected ValidatorEngine ConfigureValidator(NHibernate.Cfg.Configuration configuration)
 {
     var nhvc = new FluentConfiguration();
     nhvc.SetDefaultValidatorMode(ValidatorMode.UseExternal).IntegrateWithNHibernate.ApplyingDDLConstraints();
     nhvc.Register<PersonValidation, Person>();
     nhvc.Register<NameValidation, Name>();
     var engine = new ValidatorEngine();
     engine.Configure(nhvc);
     return engine;
 }

 protected override void Configure(NHibernate.Cfg.Configuration configuration)
 {
     base.Configure(configuration);
     var nhvc = new FluentConfiguration();
     nhvc.SetDefaultValidatorMode(ValidatorMode.UseAttribute).IntegrateWithNHibernate.ApplyingDDLConstraints().And.
         RegisteringListeners();
     var onlyToUseToInitializeNh_Engine = new ValidatorEngine();
     onlyToUseToInitializeNh_Engine.Configure(nhvc);
     configuration.Initialize(onlyToUseToInitializeNh_Engine);
 }

        public void Configure()
        {
            ValidatorEngine ve = new ValidatorEngine();

            ve.Configure();
            Assert.AreEqual(true, ve.ApplyToDDL);
            Assert.AreEqual(true, ve.AutoRegisterListeners);
            Assert.AreEqual(ValidatorMode.UseAttribute, ve.DefaultMode);
            Assert.IsNotNull(ve.Interpolator);
            Assert.AreEqual(typeof(PrefixMessageInterpolator), ve.Interpolator.GetType());
        }

        public void DelegatedValidate_WithoutMessageHasInvalidValue()
        {
            var configure = new FluentConfiguration();
            configure.Register(new[] { typeof(RangeDefWithoutCustomMessage) })
                .SetDefaultValidatorMode(ValidatorMode.UseExternal);
            var ve = new ValidatorEngine();

            ve.Configure(configure);
            var iv = ve.Validate(new Range {Start = 5, End = 4});
            iv.Should().Not.Be.Empty();
        }