Why does nhibernate need virtual properties

First of all, there is a minor performance cost to calling virtual members as opposed to calling non virtual members. However, this performance cost is really extremely small and in practically every situation it's completely negligible. This extra cost certainly doesn't even compare to some real world performance costs, like hitting the database more often than you should or retrieving more data than you really need.

Another reason why some people don't like this is because they don't like to enable derived classes to override whatever member they want to.

In some cases, this is a valid objection. In most cases however, it's pure Intellectual Masturbation which offers no real value at all. There are other ORM's that don't require you to make your members virtual and they are still able to offer lazy loading features.

But those ORM's usually require you to either inherit from a specified base class, or to implement one or more interfaces that the ORM will use. In both cases, I'd argue that this pollutes your entities far more than virtual members do, but that's just my opinion. But for those cases where you really do not want to make members virtual, and don't mind forgoing on the lazy-loading features of NHibernate, you can simply map those entities to not enable lazy loading at all.

You could just map an entity like this:. Setting the lazy attribute to false will ensure that NHibernate will not create a proxy type of your entity type, and that you will always be dealing with instances of the actual type of your entity instead of a possible proxy type.

It also means that you will never be able to use any kind of lazy loading when it comes to retrieving instances of these entity types. Skip to content. I find it much more difficult to manage your session in a desktop application, because you cannot take advantage of such a clear bondary like What does Cascade in Nhibernate mean? And in which scenarios are these reasons valid?

Some reasons Any other reasons? I'm new to NHibernate, and have seen some issues when closing sessions prematurely. I've solved this temporarily by reusing sessions instead of opening a Persistent entities don't necessarily have to be represented as POCO classes at runtime. NHibernate also supports dynamic models using Dictionaries or C dynamic. With this approach, you don't write persistent classes, only mapping files. The following examples demonstrates the dynamic model feature.

First, in the mapping file, an entity-name has to be declared instead of a class name:. Note that even though associations are declared using target class names, the target type of an associations may also be a dynamic entity instead of a POCO. The advantages of a dynamic mapping are quick turnaround time for prototyping without the need for entity class implementation. However, you lose compile-time type checking and will very likely deal with many exceptions at runtime.

Thanks to the NHibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on. Tuplizer , and its sub-interfaces, are responsible for managing a particular representation of a piece of data, given that representation's NHibernate.

If a given piece of data is thought of as a data structure, then a tuplizer is the thing which knows how to create such a data structure and how to extract values from and inject values into such a data structure. There are two high-level types of Tuplizers, represented by the NHibernate.

IEntityTuplizer and NHibernate. IComponentTuplizer interfaces. IEntityTuplizer s are responsible for managing the above mentioned contracts in regards to entities, while IComponentTuplizer s do the same for components. Users may also plug in their own tuplizers. Both would be achieved by defining a custom tuplizer implementation. Tuplizers definitions are attached to the entity or component mapping they are meant to manage.

Going back to the example of our customer entity:. The NHibernate IInterceptor offers a less intrusive alternative, however. OnSave - called just before the object is saved or inserted. Daniel Auger Daniel Auger In case you are not using of the mentioned methods which are not virtual, you can simply add the SetProperty of the following snippet: NHibernate. SetProperty NHibernate. UseProxyValidator, Boolean. FalseString This simply turns off the validation causing the error, make sure you are not using non virtual methods as NHibernate will fail to proxy them as suggested by the original error.

Sign up or log in Sign up using Google. Sign up using Facebook. Sign up using Email and Password. Post as a guest Name. Email Required, but never shown. The Overflow Blog.