C# CustomizersHolder类代码示例

        public void InvokeDirectMethods()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyCollection));
            var customizersHolder = new CustomizersHolder();
            var customizer = new CollectionElementCustomizer(propertyPath, customizersHolder);
            var elementMapper = new Mock<IElementMapper>();

            customizer.Length(10);
            customizer.Precision(5);
            customizer.Scale(2);
            customizer.NotNullable(true);
            customizer.Unique(true);
            customizer.Column("pizza");
            customizer.Type(NHibernateUtil.StringClob);
            customizer.Type<MyUserType>();
            var parameters = new {something= 10};
            customizer.Type<MyUserType>(parameters);
            customizer.Type(typeof(MyUserType), parameters);

            customizersHolder.InvokeCustomizers(propertyPath, elementMapper.Object);

            elementMapper.Verify(x => x.Length(It.Is<int>(v => v == 10)), Times.Once());
            elementMapper.Verify(x => x.Precision(It.Is<short>(v => v == 5)), Times.Once());
            elementMapper.Verify(x => x.Scale(It.Is<short>(v => v == 2)), Times.Once());
            elementMapper.Verify(x => x.Unique(It.Is<bool>(v => v)), Times.Once());
            elementMapper.Verify(x => x.NotNullable(It.Is<bool>(v => v)), Times.Once());
            elementMapper.Verify(x => x.Column(It.Is<string>(v => v == "pizza")), Times.Once());
            elementMapper.Verify(x => x.Type(It.Is<IType>(v => v.GetType() == NHibernateUtil.StringClob.GetType())), Times.Once());
            elementMapper.Verify(x => x.Type<MyUserType>(), Times.Once());
            elementMapper.Verify(x => x.Type<MyUserType>(It.Is<object>(v=> v == parameters)), Times.Once());
            elementMapper.Verify(x => x.Type(It.Is<Type>(v=> v == typeof(MyUserType)), It.Is<object>(v => v == parameters)), Times.Once());
        }

        public void InvokingCustomizerOnBagThenInvokeCollectionPropertiesCustomizer()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyCollection));
            var customizersHolder = new CustomizersHolder();
            var concreteCollectionMapper = new Mock<IBagPropertiesMapper>();

            customizersHolder.AddCustomizer(propertyPath, (ICollectionPropertiesMapper x) => x.BatchSize(10));
            customizersHolder.InvokeCustomizers(propertyPath, concreteCollectionMapper.Object);

            concreteCollectionMapper.Verify(x => x.BatchSize(It.Is<int>(v => v == 10)), Times.Once());
        }

        public void InvokeCustomizerOfDictionaryKeyManyToManyRelation()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyDictionary));
            var customizersHolder = new CustomizersHolder();
            var elementMapper = new Mock<IMapKeyManyToManyMapper>();

            customizersHolder.AddCustomizer(propertyPath, (IMapKeyManyToManyMapper x) => x.Column("pizza"));
            customizersHolder.InvokeCustomizers(propertyPath, elementMapper.Object);

            elementMapper.Verify(x => x.Column(It.Is<string>(v => v == "pizza")), Times.Once());
        }

        public void InvokeCustomizerOfCollectionOneToManyRelation()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyCollection));
            var customizersHolder = new CustomizersHolder();
            var elementMapper = new Mock<IOneToManyMapper>();

            customizersHolder.AddCustomizer(propertyPath, (IOneToManyMapper x) => x.NotFound(NotFoundMode.Ignore));
            customizersHolder.InvokeCustomizers(propertyPath, elementMapper.Object);

            elementMapper.Verify(x => x.NotFound(It.Is<NotFoundMode>(v => v == NotFoundMode.Ignore)), Times.Once());
        }

        public void InvokeCustomizerOfCollectionElementRelation()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyCollection));
            var customizersHolder = new CustomizersHolder();
            var elementMapper = new Mock<IElementMapper>();

            customizersHolder.AddCustomizer(propertyPath, (IElementMapper x) => x.Length(10));
            customizersHolder.InvokeCustomizers(propertyPath, elementMapper.Object);

            elementMapper.Verify(x => x.Length(It.Is<int>(v => v == 10)), Times.Once());
        }

        public void InvokeSetOfSchemaAction()
        {
            var customizersHolder = new CustomizersHolder();
            var customizer = new ClassCustomizer<MyClass>(customizersHolder);
            var classMapper = new Mock<IClassAttributesMapper>();

            customizer.SchemaAction(SchemaAction.None);
            customizersHolder.InvokeCustomizers(typeof(MyClass), classMapper.Object);

            classMapper.Verify(x => x.SchemaAction(SchemaAction.None));
        }

		public void MergeShouldMergeElementMapper()
		{
			var emptyHolder = new CustomizersHolder();
			var holder = new CustomizersHolder();
			var called = false;

			holder.AddCustomizer(propertyPath, (IElementMapper x) => called = true);
			emptyHolder.Merge(holder);
			emptyHolder.InvokeCustomizers(propertyPath, (IElementMapper)null);

			called.Should().Be.True();
		}

		public void MergeShouldMergeCollectionPropertiesMapper()
		{
			var emptyHolder = new CustomizersHolder();
			var holder = new CustomizersHolder();
			var called = false;

			holder.AddCustomizer(propertyPath, (ICollectionPropertiesMapper x) => called = true);
			emptyHolder.Merge(holder);
			emptyHolder.InvokeCustomizers(propertyPath, (IBagPropertiesMapper)null);

			Assert.That(called, Is.True);
		}

        public void InvokeFilterMapping()
        {
            var customizersHolder = new CustomizersHolder();
            var customizer = new ClassCustomizer<MyClass>(customizersHolder);
            var classMapper = new Mock<IClassAttributesMapper>();
            var filterMapper = new Mock<IFilterMapper>();
            classMapper.Setup(x => x.Filter(It.IsAny<string>(), It.IsAny<Action<IFilterMapper>>())).Callback<string, Action<IFilterMapper>>(
                (name, x) => x.Invoke(filterMapper.Object));

            customizer.Filter("pizza",x => x.Condition("any condition"));
            customizersHolder.InvokeCustomizers(typeof(MyClass), classMapper.Object);

            filterMapper.Verify(x => x.Condition(It.Is<string>(v => v == "any condition")));
        }

        public void WhenRegisteredCustomizerForDictionaryThenCallElementMapperAction()
        {
            var orm = GetBaseMockedDomainInspector();
            orm.Setup(x => x.IsDictionary(It.Is<MemberInfo>(m => m == ForClass<Person>.Property(p => p.Farm)))).Returns(true);
            bool customizerInvoked = false;
            var propertyPath = new PropertyPath(null, ForClass<Person>.Property(p => p.Farm));
            var customizersHolder = new CustomizersHolder();
            customizersHolder.AddCustomizer(propertyPath, (IOneToManyMapper x) => customizerInvoked = true);

            var mapper = new Mapper(orm.Object, customizersHolder);
            mapper.CompileMappingFor(new[] { typeof(Person) });

            customizerInvoked.Should().Be.True();
        }

        public void InvokeOnDelete()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyCollection));
            var customizersHolder = new CustomizersHolder();
            var customizer = new CollectionKeyCustomizer<MyClass>(propertyPath, customizersHolder);
            var collectionMapper = new Mock<ISetPropertiesMapper>();
            var keyMapper = new Mock<IKeyMapper>();
            collectionMapper.Setup(x => x.Key(It.IsAny<Action<IKeyMapper>>())).Callback<Action<IKeyMapper>>(
                x => x.Invoke(keyMapper.Object));

            customizer.OnDelete(OnDeleteAction.Cascade);
            customizersHolder.InvokeCustomizers(propertyPath, collectionMapper.Object);

            keyMapper.Verify(x => x.OnDelete(It.Is<OnDeleteAction>(v => v == OnDeleteAction.Cascade)), Times.Once());
        }

        public void InvokeColumn()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyCollection));
            var customizersHolder = new CustomizersHolder();
            var customizer = new CollectionKeyCustomizer<MyClass>(propertyPath, customizersHolder);
            var collectionMapper = new Mock<ISetPropertiesMapper>();
            var keyMapper = new Mock<IKeyMapper>();
            collectionMapper.Setup(x => x.Key(It.IsAny<Action<IKeyMapper>>())).Callback<Action<IKeyMapper>>(
                x => x.Invoke(keyMapper.Object));

            customizer.Column("pizza");
            customizersHolder.InvokeCustomizers(propertyPath, collectionMapper.Object);

            keyMapper.Verify(x => x.Column(It.Is<string>(str => str == "pizza")), Times.Once());
        }

        public void InvokeCache()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyCollection));
            var customizersHolder = new CustomizersHolder();
            var customizer = new CollectionPropertiesCustomizer<MyClass, MyEle>(propertyPath, customizersHolder);
            var collectionMapper = new Mock<ISetPropertiesMapper>();
            var cacheMapper = new Mock<ICacheMapper>();
            collectionMapper.Setup(x => x.Cache(It.IsAny<Action<ICacheMapper>>())).Callback<Action<ICacheMapper>>(
                x => x.Invoke(cacheMapper.Object));

            customizer.Cache(x=> x.Region("static"));
            customizersHolder.InvokeCustomizers(propertyPath, collectionMapper.Object);

            cacheMapper.Verify(x => x.Region(It.Is<string>(v => v == "static")));
        }

        public void InvokeColumnCustomizer()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyCollection));
            var customizersHolder = new CustomizersHolder();
            var customizer = new CollectionElementCustomizer(propertyPath, customizersHolder);
            var elementMapper = new Mock<IElementMapper>();
            var columnMapper = new Mock<IColumnMapper>();
            elementMapper.Setup(x => x.Column(It.IsAny<Action<IColumnMapper>>())).Callback<Action<IColumnMapper>>(
                x => x.Invoke(columnMapper.Object));

            customizer.Column(c => c.SqlType("VARCHAR(100)"));
            customizersHolder.InvokeCustomizers(propertyPath, elementMapper.Object);

            columnMapper.Verify(x => x.SqlType(It.Is<string>(v => v == "VARCHAR(100)")));
        }

        public void InvokeIndex()
        {
            var propertyPath = new PropertyPath(null, ForClass<MyClass>.Property(x => x.MyCollection));
            var customizersHolder = new CustomizersHolder();
            var customizer = new ListPropertiesCustomizer<MyClass, int>(propertyPath, customizersHolder);
            var collectionMapper = new Mock<IListPropertiesMapper>();
            var listIndexMapper = new Mock<IListIndexMapper>();
            collectionMapper.Setup(x => x.Index(It.IsAny<Action<IListIndexMapper>>())).Callback<Action<IListIndexMapper>>(
                x => x.Invoke(listIndexMapper.Object));

            customizer.Index(x => x.Base(1));
            customizersHolder.InvokeCustomizers(propertyPath, collectionMapper.Object);

            listIndexMapper.Verify(x => x.Base(It.Is<int>(v => v == 1)));
        }