NHibernate Archives - Andriy Buday

My talk at #kievaltnet about NHibernate internals

December 4, 2011 Conferences, NHibernate, Presentation, Success 2 comments

Friday I’ve been in Kiev, the capital of Ukraine. At the beginning of the day me with my wife visited couple of shops to buy some special things my wife makes. And than we went to have a good sit in small restaurant till 7 PM. I had to finish up my presentation…

Recently I’ve mentioned that I will be speaking at Kiev ALT.NET. So this post is about it.

Kiev ALT.NET

Kiev ALT.NET is great group of smart people willing to learn interesting things in .net but maybe from deeper standpoint than standard .net user groups do. I’ve been having good conversations in twitter with @chaliy and once we met at UnetaPlus in Kharkiv where he invited me as speaker to the @kievaltnet. Peliminary we agreed on something about NHibernate.

The topic

I knew that I have to prepare something interesting on NHibernate. But what? There are dozen of articles on it, there are many videos available. Topic just came itself. You might know that I’ve been working with NH for long time already and that I’ve written something similar to ORM so I decided that getting some insight into NHibernate’s guts would be really interesting.

Presentation delivery

So before 7 PM I got to the Ciklum office (building on the left). Landscapes from the 20th floor are astonishing, especially at night.

Not sure if I was enough prepared, but at least I felt that guys were listening to me very-very attentively. Some of them twitted simultaneously (@alexbeletsky, @skalinets, @korneliuk) and had good laugh. At least I invented term “swiss breakpoint” (aka. conditional breakpoint with cross).

More photos can be seen on facebook’s page here of the Kiev ALT.NET group.

Also I tried to joke much, but it didn’t go as well as I expected it to, guess because of sleepless night and general tiredness. Also I spoke with accent (as per them o_O. Never thought I have any kind of accent of my native language).

Presentation itself

View more presentations from Andriy Buday.

I would like to thank all guys, who came to listen to me and other presenters. Thanks for having me at Kiev ALT.NET. It had been great time and I would like to be there once again despite reason (to speak or to listen).

2 comments

Upgrading to higher version of NHibernate w/ FluentNH

August 23, 2011 NHibernate No comments

“How much would it take?” – Yeah, it is interesting question, which we gave to ourselves being maybe 3rd year of developing projects based on NHibernate. We took quick look and from top of the head it looks like it would take a lot of time, because FluentNhibernate has changed syntaxes, because there might be something not working after changes, etc.

You know what? I was able to change version of NHibernate and make it working for us within 25 minutes.

It just proves known statement about giving estimates: “Judge as last resort!” Better compute and much better count if applicable.

So what is needed to be changed when you are upgrading to higher version of NHibernate w/ FluentNHiberante (from 2.0.0.4000 to 3.1.0.4000):

Download compatible versions of NH and FNH. Usually FNH is step behind. (see release notes)
Update references of your projects if you have folders for versions of 3rdParties.
Update fluent initialization of NH with adding proxyfactory, like below:

var configuration = new Configuration();
var properties = new Dictionary<string, string>();
properties.Add(“proxyfactory.factory_class”, “NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle”);

4. Also you would need to reference NHibernate.ByteCode.Castle in your starting project.

5. Update fluent mapping with removing different noise code like below (if you are below 1.0 version):

We had about 250 mapping files so “Ctrl+H” had to be used a lot.
6. Run your application and see if you don’t have any issues.

So, long story short, updating to higher version of NH is not painful. It is still not clear if it has big impact or not, especially for big project.

If we decide to upgrade I will let you know if testing shows big impact.

No comments

Distributed transactions with NHibernate

January 31, 2011 NHibernate No comments

Most of our current NHibernate saving methods look like below:

        public void SaveCustomer(CustomerEntity customer)
        {
            var transaction = GetActiveTransaction();

            transaction.Begin();
            try
            {
                // some code
                Session.SaveOrUpdate(customer);

                transaction.Commit();
            }
            catch (Exception e)
            {
                transaction.Rollback();
                throw e;
            }
        }

this works great if you need to save just Customer or just Vendor. But in recent time we got kindof challenge to save Customer and Vendor at once in scope of one transaction for piece of functionality, and at the same time method should work for another piece of functionality.
For this we change our methods as following:

        public void SaveVendor(VendorEntity vendor)
        {
            using (var scope = new TransactionScope(TransactionScopeOption.Required)) // if there is no transaction scope, new will be created...
            {
                using (var transaction = Session.BeginTransaction())
                {
                    // some code
                    Session.SaveOrUpdate(vendor);

                    transaction.Commit();
                }
                scope.Complete();
            }
        }

Now we can utilize our methods higher in the call stack:

        public void SaveBunchOfInformationAtOnce(CustomerEntity customer, VendorEntity vendor)
        {
            try
            {
                using(var scope = new TransactionScope(TransactionScopeOption.RequiresNew)) // always new transaction will be created
                {
                    CustomersRepository.SaveCustomer(customer);

                    VendorsRepository.SaveVendor(vendor);

                    scope.Complete();
                }
            }
            catch(Exception e)
            {
                // log errors...
                throw;
            }
        }

This all works just fine both for existing method calls and for new one. Hope it helps.
Next thing that I might need to put into place is to distribute transactions through WCF services. That should be fun.

No comments

Allow set in your POCO or write crappy resolvers for AutoMapper or what?

December 20, 2010 AutoMapper, NHibernate 2 comments

In my project we are using NHibernate and Automapper to automatically map heavy database objects to light DTO object that we send across the wire. This works just fine, unless you have to map light object received to the POCO class.

Accordingly to all normal recommendations and just good common sense. You would not expose properties of your database objects with setter. Because ORM should fetch object graph in consistent state. And when you want to set Customer for Order you would probably use SetCustomer() method for better visibility and in

    public class Order
    {
        private Customer _customer = new Customer();
        public virtual int OrderId { get; set; }
        public virtual DateTime OrderDate { get; set; }
        public virtual Customer Customer { get { return _customer;}}
    }

and in mapping you would write something similar to this:

    public class OrderMap : ClassMap
    {
        public OrderMap()
        {
            WithTable("`Order`");

            Id(x => x.OrderId);
            Map(x => x.OrderDate, "OrderDate");

            References(x => x.Customer)
                .Access.AsCamelCaseField(Prefix.Underscore)
                .WithForeignKey("CustomerId");
        }
    }

as you can see, we set value for Customer using reflection deep inside of NHibernate. Also this approach ensures us that newly created Order will have default Customer object. But when we come to mapping OrderModel, which looks like below:

    [DataContract]
    public class OrderModel
    {
        [DataMember]
        public virtual int OrderId { get; set; }
        [DataMember]
        public virtual DateTime OrderDate { get; set; }
        [DataMember]
        public virtual CustomerModel Customer { get; set; }
    }

OrderModel.Customer simply doesn’t map to Order.Customer, since AutoMapper doesn’t have access to write into that value. Sadly, but AutoMapper doesn’t have any convention like NHibernate .Access.AsCamelCaseField(Prefix.Underscore), which means that it will look for _customer.

And now! AutoMapper is much smarter than NHibernate. You don’t need any conventions you can simply put private set and you are good! So I did:

    public class Order
    {
        private Customer _customer = new Customer();
        public virtual int OrderId { get; set; }
        public virtual DateTime OrderDate { get; set; }
        public virtual Customer Customer
        {
         get { return _customer;}
         private set { _customer = value;}
        }
    }

Honestly I wouldn’t write this post if I had knew about this possibility before I started writing it. But since I wrote more than half of what you see I decided to finish the story. Enjoy or blame me. Anyway for myself I took following: sniff around features and components you are using, some of them have better ideas than others, your task is to absorb the best!

2 comments

Understanding FetchMode

August 29, 2010 NHibernate No comments

Few days ago I’ve faced with duplication of data in XML we send to vendors and it leaded my to basic understanding how fetching works within NHibernate.

Database

So to make things clear we will start with ever simplest database layout and few datarows as on picture below:

I’m using following code to test our activities.

private void FetchCustomerUseOrders(ISession session, FetchMode fetchMode)

{

var criteria = session.CreateCriteria(typeof(Customer))

.SetFetchMode(“Orders”, fetchMode)

.Add(Restrictions.Eq(“CustomerId”, 10));

var customers = criteria.List<Customer>();

Console.WriteLine(customers[0].Orders.Count);

}

It fetches Customer with passed in FetchMode and then uses Orders to examine how lazy loading works.

Then I’m calling method for each of the FetchMode in separate sessions like below: