C# ClassMap类代码示例

        public void ShouldHaveSameTableNameForBothSidesOfMappingWhenRightSpecified()
        {
            var model = new PersistenceModel();
            var leftMap = new ClassMap<Left>();

            leftMap.Id(x => x.Id);
            leftMap.HasManyToMany(x => x.Rights);

            var rightMap = new ClassMap<Right>();

            rightMap.Id(x => x.Id);
            rightMap.HasManyToMany(x => x.Lefts)
                .Table("MyJoinTable");

            model.Add(leftMap);
            model.Add(rightMap);

            var mappings = model.BuildMappings();

            var leftMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Left)).First();
            var rightMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Right)).First();

            leftMapping.Collections.First().TableName.ShouldEqual("MyJoinTable");
            rightMapping.Collections.First().TableName.ShouldEqual("MyJoinTable");
        }

        public void CanCreateClassMap()
        {
            var classMap = new ClassMap<Artist>();
            ClassMapping mapping = classMap.GetClassMapping();

            mapping.Type.ShouldEqual(typeof(Artist));
        }

 public void SetUp()
 {
     tourMap = new ClassMap<Tour>(Version.LUCENE_30);
     tourMap.Property(p => p.AccommodationAges).Stored().NotAnalyzed();
     tourMap.Property(p => p.TotalPriceMin).Stored().NotAnalyzed();
     tourMap.Property(p => p.TotalPriceMax).Stored().NotAnalyzed();
 }

        public void ShouldAllowConventionsToAlterBiDirectionalTableNames()
        {
            var model = new PersistenceModel();
            var leftMap = new ClassMap<Left>();

            leftMap.Id(x => x.Id);
            leftMap.HasManyToMany(x => x.Rights);

            var rightMap = new ClassMap<Right>();

            rightMap.Id(x => x.Id);
            rightMap.HasManyToMany(x => x.Lefts);

            model.Add(leftMap);
            model.Add(rightMap);
            model.Conventions.Add<TestTableNameConvention>();

            var mappings = model.BuildMappings();

            var leftMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Left)).First();
            var rightMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Right)).First();

            leftMapping.Collections.First().TableName.ShouldEqual("Lefts_Rights");
            rightMapping.Collections.First().TableName.ShouldEqual("Lefts_Rights");
        }

        public void GenerateIdsFor(object entity, ClassMap classMap)
        {
            this.currentClassMap = classMap;
            this.currentEntity = entity;

            this.Visit(classMap);
        }

        private void Mapping(Action<KeyManyToOnePart> mappingDefinition)
        {
            var classMap = new ClassMap<ExampleClass>();
            var map = classMap.CompositeId()
                .KeyProperty(x => x.Id)
                .KeyReference(x => x.Parent, mappingDefinition);

            mapping = classMap;
        }

        public void CanMapProperty()
        {
            var classMap = new ClassMap<Artist>();
            classMap.Map(x => x.Name);
            ClassMapping mapping = classMap.GetClassMapping();

            var property = mapping.Properties.FirstOrDefault();
            property.ShouldNotBeNull();
            property.MappedMember.ShouldEqual(ReflectionHelper.GetMember<Artist>(x => x.Name));
        }

        public void CanMapCollection()
        {
            var classMap = new ClassMap<Artist>();
            classMap.HasMany<Album>(x => x.Albums);
            ClassMapping mapping = classMap.GetClassMapping();

            var collection = mapping.Collections.FirstOrDefault() as BagMapping;
            collection.ShouldNotBeNull();
            collection.MappedMember.ShouldEqual(ReflectionHelper.GetMember<Artist>(x => x.Albums));
        }

        public void CanMapReference()
        {
            var classMap = new ClassMap<Album>();
            classMap.References(x => x.Artist);
            ClassMapping mapping = classMap.GetClassMapping();

            var reference = mapping.References.FirstOrDefault();
            reference.ShouldNotBeNull();
            reference.MappedMember.ShouldEqual(ReflectionHelper.GetMember<Album>(x => x.Artist));
        }

 public void NeverShouldSetDefaultLazyToFalse()
 {
     var classMap = new ClassMap<Target>();
     classMap.Id(x => x.Id);
     model.Add(classMap);
     model.Conventions.Add(DefaultLazy.Never());
     model.BuildMappings()
         .First()
         .DefaultLazy.ShouldBeFalse();
 }

 public void ShouldSetDefaultAccessToValue()
 {
     var classMap = new ClassMap<Target>();
     classMap.Id(x => x.Id);
     model.Add(classMap);
     model.Conventions.Add(AutoImport.Never());
     model.BuildMappings()
         .First()
         .AutoImport.ShouldEqual(false);
 }

 public void AlwaysShouldSetDefaultLazyToTrue()
 {
     var classMap = new ClassMap<Target>();
     classMap.Id(x => x.Id);
     model.Add(classMap);
     model.Conventions.Add(DefaultLazy.Always());
     model.BuildMappings()
         .First()
         .DefaultLazy.ShouldBeTrue();
 }

 public void ShouldSetDefaultAccessToValue()
 {
     var classMap = new ClassMap<Target>();
     classMap.Id(x => x.Id);
     model.Add(classMap);
     model.Conventions.Add(DefaultAccess.Field());
     model.BuildMappings()
         .First()
         .DefaultAccess.ShouldEqual("field");
 }

        public override void establish_context()
        {
            inline_component = new ClassMap<Target>();
            inline_component.Component(x => x.ComponentProperty, c => c.Map(x => x.Property));

            external_component = new ComponentMap<Component>();
            external_component.Map(x => x.Property);

            reference_component = new ClassMap<Target>();
            reference_component.Component(x => x.ComponentProperty);
        }

        public Document CreateDocument(ClassMap classMap, object entity)
        {
            if (entity == null)
                throw new ArgumentNullException("entity");
            this.entity = entity;

            this.document = new Document();
            classMap.Accept(this);

            return this.document;
        }