{"id":377,"date":"2009-08-24T21:36:14","date_gmt":"2009-08-24T20:36:14","guid":{"rendered":"http:\/\/blog.eweibel.net\/?p=377"},"modified":"2012-04-29T15:09:34","modified_gmt":"2012-04-29T13:09:34","slug":"nhibernate-mapping-posibilities","status":"publish","type":"post","link":"https:\/\/blog.eweibel.net\/?p=377","title":{"rendered":"NHibernate mapping possibilities"},"content":{"rendered":"

I prepare currently a new talk about NHibernate<\/a>. In this talk I’ll show the different mapping possibilities with NHibernate. To demonstrate the three possibilities (and a fourth one) I chose a quite simple model: I implement three classes Cat, Dog and Bird an for each one I chose a different mapping approach. For my little sample application I used NHibernate 2.1.0, NHibernate.Mapping.Attributes 2.1.0 and Fluent NHibernate 1.0.0.545.<\/p>\n

NHibernate classic style – XML-Files<\/strong>
\nFor the class Cat I chose to use the classic way to map the class.
\n[code language=”csharp”]
\npublic class Cat
\n{
\n\tprivate string id;
\n\tprivate string name;
\n\tprivate char sex;
\n\tprivate float weight;<\/p>\n

\tpublic virtual string Id
\n\t{
\n\t\tget { return id; }
\n\t\tset { id = value; }
\n\t}<\/p>\n

\tpublic virtual string Name
\n\t{
\n\t\tget { return name; }
\n\t\tset { name = value; }
\n\t}<\/p>\n

\tpublic virtual char Sex
\n\t{
\n\t\tget { return sex; }
\n\t\tset { sex = value; }
\n\t}<\/p>\n

\tpublic virtual float Weight
\n\t{
\n\t\tget { return weight; }
\n\t\tset { weight = value; }
\n\t}
\n}
\n[\/code]
\nAnd the XML-File Cat.hbm.xml looks like:
\n[code language=”xml”]
\n<?xml version="1.0" encoding="utf-8" ?>
\n<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" namespace="NHibernateTest.Domain" assembly="NHibernateTest">
\n\t<class name="Cat" table="Cat">
\n\t\t<id name="Id">
\n\t\t\t<column name="CatId" sql-type="char(32)"\/>
\n\t\t\t<generator class="uuid.hex" \/>
\n\t\t<\/id>
\n\t\t<property name="Name">
\n\t\t\t<column name="Name" length="16" not-null="true" \/>
\n\t\t<\/property>
\n\t\t<property name="Sex" \/>
\n\t\t<property name="Weight" \/>
\n\t<\/class>
\n<\/hibernate-mapping>
\n[\/code]
\nThis approach has different problems: You couldn’t easily refactor your POCOs, you have to adapt the hbm.xml files too. Another problem is that you write your entity twice: in C# and in XML, so there is a lot of noise. This is the entry point for code generation, but it isn’t a real solution, it is just a workaround to handle the necessary XML file correctly and to reduce errors by manual writing.<\/p>\n

NHibernate.Mapping.Attributes<\/strong>
\nFor the class Dog I prefer the attributes <\/a>to map the class. In JPA<\/a> it is my preferred way for simple and small projects, so I was very interested how they ported this approach to .Net.
\n[code language=”csharp”]
\n[Class(NameType = typeof(Dog))]
\npublic class Dog
\n{
\n\tprivate Guid id;
\n\tprivate string strName;<\/p>\n

\t[Id(0,
\n\tColumn = "ID",
\n\tName = "ID",
\n\tTypeType = typeof(Guid),
\n\tUnsavedValue = "(00000000-0000-0000-0000-000000000000)"
\n\t)]
\n\t[Generator(1, Class = "guid.comb")]
\n\tpublic virtual Guid ID
\n\t{
\n\t\tget { return id; }
\n\t\tprivate set { id = value; }
\n\t}<\/p>\n

\t[Property(0, Column = "Name",
\n\tName = "Name",
\n\tTypeType = typeof(string),
\n\tLength = 50,
\n\tNotNull = false
\n\t)]
\n\tpublic virtual string Name
\n\t{
\n\t\tget { return strName; }
\n\t\tset { strName = value; }
\n\t}
\n}
\n[\/code]
\nWithout the property NameType in the Class-attribute the sample doesn’t run. Another thing which disturbs me is the noise in the code by the attributes. It isn’t a clean POCO approach, also because the needed specific using statements.<\/p>\n

Fluent NHibernate<\/strong>
\nFinally there is a third approach<\/a> how to map a class. To demonstrate this possibility a use the Bird class:
\n[code language=”csharp”]
\npublic class Bird
\n{
\n\tprivate Guid id;
\n\tprivate string strName;<\/p>\n

\tpublic virtual Guid ID
\n\t{
\n\t\tget { return id; }
\n\t\tprivate set { id = value; }
\n\t}<\/p>\n

\tpublic virtual string Name
\n\t{
\n\t\tget { return strName; }
\n\t\tset { strName = value; }
\n\t}
\n}
\n[\/code]
\nFor the mapping you have to use an additional class, which looks like that:
\n[code language=”csharp”]
\npublic class BirdMapping : ClassMap<Bird>
\n{
\n\tpublic BirdMapping()
\n\t{
\n\t\tId(x => x.ID);
\n\t\tMap(x => x.Name);
\n\t}
\n}
\n[\/code]
\nThis approach is really interesting. You separate your mapping from your entity, but the mapping is written in the same language like the entity itself. So you can profit of the refactor features of your IDE or of an additional tool like Resharper<\/a>.<\/p>\n

Use all together in the same project<\/strong>
\nI tried to run all the three possibilities in one project and I used a factory method<\/a> to create the NHibernate configuration instance. This method looks like that:
\n[code language=”csharp”]
\npublic static Configuration CreateConfiguration()
\n{
\n\tConfiguration config = new Configuration();
\n\tconfig.Configure();<\/p>\n

\t\/\/ XML-Files
\n\tconfig.AddAssembly(Assembly.GetExecutingAssembly());<\/p>\n

\t\/\/ Attributes
\n\tHbmSerializer.Default.Validate = true; \/\/ Enable validation (optional)
\n\tHbmSerializer.Default.Serialize(System.Environment.CurrentDirectory, Assembly.GetExecutingAssembly());
\n\tconfig.AddDirectory(new DirectoryInfo(System.Environment.CurrentDirectory));<\/p>\n

\t\/\/ Fluent
\n\tconfig = Fluently.Configure(config).Mappings(m => m.FluentMappings.AddFromAssemblyOf<Program>()).BuildConfiguration();<\/p>\n

\treturn config;
\n}
\n[\/code]
\nIn a real world application I wouldn’t recommend a such configuration. An architect should decide which mapping approach is adequate. But this code snippet demonstrate that it is possible to use all three mapping possibilities at the same time.<\/p>\n

The secret fourth possibility<\/strong>
\nWhen I study NHibernate Fluent I saw on their wiki the possibility to use their Auto Mapping.
\n[code language=”csharp”]
\nprivate static Configuration CreateAutoConfiguration()
\n{
\n\tvar config = Fluently.Configure()
\n\t\t\t\t.Database(MsSqlConfiguration.MsSql2005.ConnectionString(@"Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Test.mdf;Integrated Security=True;User Instance=True")
\n\t\t\t\t\t\t\t.ShowSql())
\n\t\t\t\t.Mappings(m => m.AutoMappings.Add(AutoMap
\n\t\t\t\t\t\t\t\t.Assembly(Assembly.GetExecutingAssembly())
\n\t\t\t\t\t\t\t\t.Where(t => t.Namespace == "NHibernateTest.Domain")))
\n\t\t\t\t.ExposeConfiguration(cfg => new SchemaExport(cfg).Create(false, true))
\n\t\t\t\t.BuildConfiguration();<\/p>\n

\treturn config;
\n}
\n[\/code]
\nThe other three possibilities are a little bit different: there you define the mapping for each entity, which is more or less the opposite. You map by default all your entities by convention over configuration and only the exceptions have to be declared explicitly. Note that it is even possible to generate the DB schema with the ExposeConfiguration method.
\nFor greenfield <\/a>applications or prototypes it is a great way to map your entities, but for brownfield <\/a>applications it is much harder to use. This is the case when you couldn’t discover a pattern in the database or in the entities, which you want to map. In a such scenario I would prefer one of the three other possibilities.<\/p>\n","protected":false},"excerpt":{"rendered":"

I prepare currently a new talk about NHibernate. In this talk I’ll show the different mapping possibilities with NHibernate. To demonstrate the three possibilities (and a fourth one) I chose a quite simple model: I implement three classes Cat, Dog and Bird an for each one I chose a different mapping approach. For my little sample application I used NHibernate 2.1.0, NHibernate.Mapping.Attributes 2.1.0 and Fluent NHibernate 1.0.0.545. NHibernate classic style – XML-Files For the class Cat I chose to use…<\/p>\n

Read More Read More<\/span><\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_exactmetrics_skip_tracking":false,"_exactmetrics_sitenote_active":false,"_exactmetrics_sitenote_note":"","_exactmetrics_sitenote_category":0,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[13,14],"tags":[],"class_list":["post-377","post","type-post","status-publish","format-standard","hentry","category-net","category-software-engineering"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/plOV9-65","jetpack_sharing_enabled":true,"jetpack-related-posts":[{"id":745,"url":"https:\/\/blog.eweibel.net\/?p=745","url_meta":{"origin":377,"position":0},"title":"ConfORM – Another NHibernate mapping possibility","author":"Patrick","date":"1. Sep 2010","format":false,"excerpt":"I recently hold two presentations at the .Net User Group Bern (DNUG) with Ren\u00e9 Leupold about object relational mapping in the .Net world. We showed Entity Framework 4.0 and NHibernate. My part was NHibernate. You could download the slides and samples from the DNUG website. In the two presentations I\u2026","rel":"","context":"In ".NET"","block_context":{"text":".NET","link":"https:\/\/blog.eweibel.net\/?cat=13"},"img":{"alt_text":"ConfOrmBigTransparent","src":"https:\/\/i0.wp.com\/blog.eweibel.net\/wp-content\/uploads\/ConfOrmBigTransparent_thumb.png?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":761,"url":"https:\/\/blog.eweibel.net\/?p=761","url_meta":{"origin":377,"position":1},"title":"NHibernate presentations at DNUG Bern","author":"Patrick","date":"2. Sep 2010","format":false,"excerpt":"I hold in August two presentations at the .Net User Group Bern together with Ren\u00e9 Leupold.\u00a0 In both presentations the topic was object relational mapping in the .Net world. So we showed Microsoft Entity Framework 4.0 and NHibernate. My part was NHibernate and Rene showed EF. In the first presentation\u2026","rel":"","context":"In ".NET"","block_context":{"text":".NET","link":"https:\/\/blog.eweibel.net\/?cat=13"},"img":{"alt_text":"dnugbe","src":"https:\/\/i0.wp.com\/blog.eweibel.net\/wp-content\/uploads\/dnugbe_thumb.png?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":797,"url":"https:\/\/blog.eweibel.net\/?p=797","url_meta":{"origin":377,"position":2},"title":"NHibernate day in Bologna","author":"Patrick","date":"25. Oct 2010","format":false,"excerpt":"During a whole day several speakers spoke about NHibernate and related topics. This conference was in Bologna and was very well prepared and organized. You could watch the slides and the videos of the sessions here. I joined the following sessions: Keynote Simone Chiaretta opened the conference and showed during\u2026","rel":"","context":"In ".NET"","block_context":{"text":".NET","link":"https:\/\/blog.eweibel.net\/?cat=13"},"img":{"alt_text":"NHDay_3","src":"https:\/\/i0.wp.com\/blog.eweibel.net\/wp-content\/uploads\/NHDay_3_thumb.png?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":160,"url":"https:\/\/blog.eweibel.net\/?p=160","url_meta":{"origin":377,"position":3},"title":"When to use stored procedures","author":"Patrick","date":"13. May 2009","format":false,"excerpt":"Recently I discussed with a colleague when to use stored procedures. As exptected it was quite a religious conversation. A few days later I found the following screencast: The Pros and Cons of Stored Procedures Based on the discussion and the screencast I tried to summarize my Pros and Cons:\u2026","rel":"","context":"In "Good practices"","block_context":{"text":"Good practices","link":"https:\/\/blog.eweibel.net\/?cat=5"},"img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":459,"url":"https:\/\/blog.eweibel.net\/?p=459","url_meta":{"origin":377,"position":4},"title":"Fail Fast principle","author":"Patrick","date":"22. Sep 2009","format":false,"excerpt":"Recently I received a NullReference-Exception when I called another method from a foreign component. Fortunately I had the source code of this component and I found the following code: [code language=\"csharp\"] public class AgeValidator { public Dictionary Config { get; set; } public bool Validate(int nAge) { int nMinAge =\u2026","rel":"","context":"In "Good practices"","block_context":{"text":"Good practices","link":"https:\/\/blog.eweibel.net\/?cat=5"},"img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":942,"url":"https:\/\/blog.eweibel.net\/?p=942","url_meta":{"origin":377,"position":5},"title":"Enums and inheritance in .Net","author":"Patrick","date":"9. Feb 2011","format":false,"excerpt":"In one of my current projects I had the following code (I simplified the code a bit): public string ConnectionString { get { switch(this.Importer) { case Importer.SqlServer: return \"Server=localhost;Database=Northwind\"; case Importer.SqlServerOleDb: return\"Provider=SQLOLEDB;Data Source=localhost;Initial Catalog=Northwind\"; default: throw new NotSupportedException( string.Format(\"Importer {0} is not supported yet.\", this.Importer)); } } } After running\u2026","rel":"","context":"In ".NET"","block_context":{"text":".NET","link":"https:\/\/blog.eweibel.net\/?cat=13"},"img":{"alt_text":"CodeCoverage","src":"https:\/\/i0.wp.com\/blog.eweibel.net\/wp-content\/uploads\/CodeCoverage_thumb.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/blog.eweibel.net\/wp-content\/uploads\/CodeCoverage_thumb.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/blog.eweibel.net\/wp-content\/uploads\/CodeCoverage_thumb.png?resize=525%2C300 1.5x"},"classes":[]}],"_links":{"self":[{"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=\/wp\/v2\/posts\/377","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=377"}],"version-history":[{"count":51,"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=\/wp\/v2\/posts\/377\/revisions"}],"predecessor-version":[{"id":1209,"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=\/wp\/v2\/posts\/377\/revisions\/1209"}],"wp:attachment":[{"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=377"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=377"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.eweibel.net\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=377"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}