Localization techniques

brendan2452 — Sat, 29 Oct 2011 01:07:45 GMT

Current revision posted to How to by brendan2452 on 28/10/2011 10:07:45 p.m.

Localization techniques

Filed under: IUserType, Filters, IUserType, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

It is based on implementing IUserType, providing methods to serialize and deserialize the property. This way, we make use of NHibernate extensibility to provide a seamless mechanism to store and retrieve the property in a field of the database.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

Alternatively, you can create your our own class to contain all the translations and ease the addition and removal of them as well as properties to have quick access to the current localization string based on Thread.CurrentThread.CurrentCulture. In some of the proposals in the second method discussed there are examples of such classes that can be easily adapted to this method. This, as well, can be exposed as a string through the proper getter.

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

This is an interesting approach, quite simple in explanation but uses a couple of advanced NHibernate features such as formulas and filters. The advantage is that the property of the entity is a simple string and the selection of the language to load is made through the formula based on a session parameter.

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

This one uses a nice crafted class to store and retrieve localization information and a couple of tables, one containing the dictionaries that create the relationship between the entity and the translations, that are accessed via a <map> in the mapping. (NOTE: I have not tested it, and he says that you can map several properties in the same entity with this method but not with the provided mapping)

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The method proposed here is very similar to the former one, in this case using three tables, but that's up to you. It explains how to do the mapping using an Id different from the PK (which can't be done at this moment using Fluent NHibernate, just in case you want to).

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

A very thorough example. It maps only one property per entity, simplifying the mappings and the table structure and can be more than enough for many solutions. It discusses a lot about a Registry object to hold the current locale, but you can change that to rely in Thread.CurrentThread.CurrentCulture and simplify a little bit.

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the [[howtonh:stuffynoseremedy.net/stuffy-nose-remedy/|stuffy nose remedy]] mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

John Davidson — Fri, 28 Oct 2011 14:13:21 GMT

Revision 13 posted to How to by John Davidson on 28/10/2011 11:13:21 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

liliasmit — Fri, 28 Oct 2011 13:56:54 GMT

Revision 12 posted to How to by liliasmit on 28/10/2011 10:56:54 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

John Davidson — Wed, 06 Jul 2011 13:22:53 GMT

Revision 11 posted to How to by John Davidson on 06/07/2011 10:22:53 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

ThisMBA Project reports second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

MBA Project reports — Wed, 06 Jul 2011 04:59:56 GMT

Revision 10 posted to How to by MBA Project reports on 06/07/2011 01:59:56 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This MBA Project reports second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

John Davidson — Fri, 01 Jul 2011 10:41:47 GMT

Revision 9 posted to How to by John Davidson on 01/07/2011 07:41:47 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search DUI Lawyer in huntington Beach and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

John Davidson — Fri, 01 Jul 2011 10:41:12 GMT

Revision 8 posted to How to by John Davidson on 01/07/2011 07:41:12 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.Mustuniversity | Must University

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

LCD HDTV

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

Criminal Defense Lawyer in Long Beach — Fri, 01 Jul 2011 07:43:11 GMT

Revision 7 posted to How to by Criminal Defense Lawyer in Long Beach on 01/07/2011 04:43:11 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

LCD HDTV

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

markweee — Wed, 30 Mar 2011 11:47:46 GMT

Revision 6 posted to How to by markweee on 30/03/2011 08:47:46 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

LCD HDTV

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

mikeon098 — Fri, 24 Sep 2010 17:18:41 GMT

Revision 5 posted to How to by mikeon098 on 24/09/2010 02:18:41 p.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

LCD HDTV

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

tcook23 — Thu, 26 Aug 2010 12:35:37 GMT

Revision 4 posted to How to by tcook23 on 26/08/2010 09:35:37 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

LCD HDTV

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

mike3050 — Fri, 28 May 2010 12:41:41 GMT

Revision 3 posted to How to by mike3050 on 28/05/2010 09:41:41 a.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

Marc Climent — Tue, 16 Mar 2010 15:27:42 GMT

Revision 2 posted to How to by Marc Climent on 16/03/2010 12:27:42 p.m.

Localization techniques

Filed under: IUserType, Filters, l18n, localization, property

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary (internally) but we choose to expose it as a String developing the getter (in Fabio's post) to make it easier for the user.

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)
The entity property can't be a string

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.

Localization techniques

Marc Climent — Tue, 16 Mar 2010 12:18:25 GMT

Revision 1 posted to How to by Marc Climent on 16/03/2010 09:18:25 a.m.

This page is a summary of the two main different approaches found all around the web on Property Localization using NHibernate, based on a post in spanish on my own blog.

There are roughly two main paths

Method 1: Using a custom IUserType

This method is exposed thoroughly in a Fabio Maulo`s post called Localized Property with NHibernate, in which he discusses the use of the LocalizablePropertyType found in uNhAddIns.

In the example, the property is a Dictionary but we can create our own class to contain all the translations and ease the addition and removal of them as well as properties to have quick access to the current localization string based on Thread.CurrentThread.CurrentCulture. In some of the proposals in the second method discussed there are examples of such classes that can be easily adapted to this method.

Pros:

Simple and easy
Data stored in the same table as the entity
Fairly transparent, specially if a custom object is used to simplify the access to the translations

Cons:

The value of the field is not understandable by the DBMS (no indexing, sorting or whatever)
The entity property can't be a string

Method 2: Using several tables

This second method has many variants, but all of them use one or more tables to store the translations, making them visible to the DBMS.

Proposal 2.1: Localizing NHibernate: Contextual Parameters by Ayende

Proposal 2.2: Create a multi languaged domain model with NHibernate and C# by Michal @ WebDevBros

The class called PhraseDictionary can be easily used through a IUserType with the first method.

Proposal 2.3: Mapping translations in NHibernate by Siim Viikman

The PhraseDictionary has been replaced by the Translation class, but essentially are the same, holders of the translation dictionary. Can be adapted as well to use it with method 1.

Proposal 2.4: Localizable entities with Nhibernate part 1 (part 2 and part 3) by Alkampfer

Pros:

DBMS-aware solution

Cons:

More complex mappings
More complex data structure

Conclusions

Localization is painful in most scenarios and some guidelines can be followed:

If you don't really need that a property is localizable, don't make it localizable. Ok, in most cases is not your decision. If you have choice, think it twice or thrice before making a property localizable.
If you don't need to use DBMS capabilities on the field (such as sorting), go for the first method, it's easy to to the IUserType and the mappings and as well as the serialization is well tested won't give much trouble
If you need DBMS capabilities, in most cases only some properties will need this, so instead of embracing blindly the second method, think if a mixed solution is not simpler and better for you. (Was in my case)

As a side note, if you need to index the property, think of using NHibernate.Search and Lucene.NET using method 1 and a custom Bridge implementation to store the localizations in the index.

Finally, thanks to all that participated in NHUsers discussion on the topic.