C# PersistenceModel类代码示例

        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 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 CreatePersistenceModel()
        {
            conventionFinder = MockRepository.GenerateMock<IConventionFinder>();
            model = new PersistenceModel(conventionFinder);

            cfg = Fluently.Configure()
                .Database(SQLiteConfiguration.Standard.InMemory)
                .BuildConfiguration();
        }

        public void CreatePersistenceModel()
        {
            conventionFinder = MockRepository.GenerateMock<IConventionFinder>();
            model = new PersistenceModel(conventionFinder);

            TempDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());

            RemoveArtifacts();
            Directory.CreateDirectory(TempDir);
        }

        private string render_xml(Action<PersistenceModel> addMappings)
        {
            var model = new PersistenceModel();

            addMappings(model);

            var mappings = model.BuildMappings();
            var doc = new MappingXmlSerializer().Serialize(mappings.First());

            return doc.OuterXml;
        }

        public override void establish_context()
        {
            var component_map = new ComponentMap<Component>();
            component_map.Map(x => x.Property);

            var class_map = new ClassMap<Target>();
            class_map.Component(x => x.Component);

            persistence_model = new PersistenceModel();
            persistence_model.Add(class_map);
            persistence_model.Add(component_map);
        }

        public void ShouldntDuplicateJoinMapping()
        {
            var model = new PersistenceModel();
            var classMap = new ClassMap<Target>();

            classMap.Id(x => x.Id);
            classMap.Join("other", m => m.Map(x => x.Property));

            model.Add(classMap);
            model.Configure(cfg);

            cfg.ClassMappings.First()
                .JoinClosureIterator.Count().ShouldEqual(1);
        }

        public override void establish_context()
        {
            model = new PersistenceModel();

            var comp_map = new ComponentMap<ComponentTarget>();
            comp_map.Map(x => x.Property);

            model.Add(comp_map);

            var map = new ClassMap<Target>();
            map.Id(x => x.Id);
            map.Component(x => x.Component)
                .ColumnPrefix(column_prefix);
            model.Add(map);
        }

        public void ShouldAllowOverridingOfDefaultInConventions()
        {
            var model = new PersistenceModel();

            var map = new ClassMap<IdentityExamples>();

            map.Id(x => x.Int);

            model.Conventions.Add(new IdConvention());
            model.Add(map);
            var @class = model.BuildMappings()
                .First()
                .Classes.First();

            ((IdMapping)@class.Id).Generator.Class.ShouldEqual("increment");
        }

        public void SetUp()
        {
            PersistenceModel model = new PersistenceModel();
            model.Conventions.Add(new BackfieldAccessConvention());

            model.Add(new CompositeIdModelMapping());
            model.Add(new ManyToManyModelMapping());
            model.Add(new ManyToOneModelMapping());
            model.Add(new OneToOneModelMapping());
            model.Add(new ParentModelMapping());

            var classMappings = model.BuildMappings().SelectMany(x => x.Classes).ToDictionary(x => x.Type);
            compositeId = classMappings[typeof(CompositeIdModel)];
            manyToMany = classMappings[typeof(ManyToManyModel)];
            manyToOne = classMappings[typeof(ManyToOneModel)];
            oneToOne = classMappings[typeof(OneToOneModel)];
            parent = classMappings[typeof(ParentModel)];
        }

        public void ShouldAllowSettingOfKeyInConvention()
        {
            var model = new PersistenceModel();

            var parent = new ClassMap<Parent>();
            var child = new SubclassMap<Child>();

            model.Add(parent);
            model.Add(child);
            model.Conventions.Add<SCKeyConvention>();

            var subclass = model.BuildMappings()
                .SelectMany(x => x.Classes)
                .First()
                .Subclasses.First();

            ((JoinedSubclassMapping)subclass).Key.Columns.First().Name.ShouldEqual("xxx");
            ((JoinedSubclassMapping)subclass).Key.Columns.Count().ShouldEqual(1);
        }

 public void SetUp()
 {
     var cfg = MsSqlConfiguration.MsSql2005
         .ShowSql()
         .ConnectionString.Is("Server=(local);initial catalog=nhibernate;Integrated Security=SSPI")
         .ShowSql()
         .ConfigureProperties(new Configuration());
     var mappings = cfg.CreateMappings();
     var dialect = new SQLiteDialect();
     var model = new PersistenceModel();
     model.Add(new PersonMap());
     model.AddConvention(new NamingConvention());
     var hibernateMapping = model.BuildHibernateMapping();
     var classBinder = new RootClassBinder(mappings, dialect);
     foreach (var mapping in hibernateMapping.Classes)
     {
         classBinder.Bind(mapping);
     }
     cfg.BuildMapping();
     schemaExport = new SchemaExport(cfg);
 }

        public void ComponentWithPropertiesShouldAddToModelComponentsCollection()
        {
            var classMap = new ClassMap<Parent>();

            classMap.Id(x => x.Id);

            var subclassMap = new SubclassMap<Child>();

            subclassMap.Component(x => x.Component, c => c.Map(x => x.Name));

            var model = new PersistenceModel();

            model.Add(classMap);
            model.Add(subclassMap);

            model.BuildMappings()
                .First()
                .Classes.First()
                .Subclasses.First()
                .Components.Count().ShouldEqual(1);
        }

 public SingleConnectionSessionSourceForSQLiteInMemoryTesting(IDictionary<string, string> properties, PersistenceModel model) : base(properties, model)
 {
 }

 public void MergeOutputShouldSetFlagOnFluentPersistenceModelsOnApply()
 {
     var model = new PersistenceModel();
     
     mapping.UsePersistenceModel(model);
     mapping.MergeMappings();
     mapping.Apply(new Configuration());
     
     model.MergeMappings.ShouldBeTrue();
 }