Object Relational Mapping (ORM) Using NHibernate - Part 5 - A of 8

public class Ticket
{
 public Ticket() 
{
 // CompositeID is the composite key class defined separately
 CompositeId = new CompositeKey();
 // PASSENGERS LIST PER TICKET
  Passengers = new List<Person>();
 }
 public Ticket(User user, Train train, IList<Person> passengers)
 {
 // CompositeID is the composite key from Train and Passenger
  CompositeId         = new CompositeKey();
 //SET ASSOCIATION END
  ReservedByUser      = user;
  ReservedForTrain    = train;
 //SET COMPOSITEE KEY
  CompositeId.trainKey = train.TrainId;
  CompositeId.userKey = user.UserId;
  //OTHER ENDS OF ASSOCIATION
  Iesi.Collections.Generic.ISet<Ticket> userList = user.UserBookings;
  Iesi.Collections.Generic.ISet<Ticket> trainList = train.TrainBookings;
  //SET OTHER ASSOCIATION END
   userList.Add(this);
   // CAN COMBINE PREVIOUS lines as user.UserBookings.Add(this) 
   //SET OTHER ASSOCIATION END
  trainList.Add(this);
  TicketCounter++;
 TicketNumber = TicketCounter.ToString();
 //ADD PASSENGERS TO TICKET
  Passengers = passengers;
}
 public virtual CompositeKey CompositeId { get; set;
 public virtual string TicketNumber { get; set; }
 public virtual User ReservedByUser { get; set; }
 public virtual Train ReservedForTrain { get; set; }
 protected virtual int TicketCounter { get; set; }
 public virtual IList<Person> Passengers { get; set; }
 }

The mapping code snippet Ticket.hbm is shown below. There are no surprises here. The only new tag in the mapping code is the use of the <composite-id tag for the composite key defined for the Ticket class. But what is best captured in the mapping file of the association class is the two <many-to-one tags with the Train class and the User class. Remember that we have taken the OOAD approach to deal with the many-to-many association and use NHibernate with this approach. According to this approach, the <many-to-many association between Train and User must be split into two <many-to-one associations with the "Ticket" association class. The two <many-to-one mappings in the Ticket.hbm mapping file below show clearly how this is done in NHibernate.

<class name="Ticket" table="TICKET" >
<composite-id name="CompositeId" class="CompositeKey">
<key-property name="userKey" access="field" column="USERID" type="long"/>
<key-property name="trainKey" access="field" column="TRAINID" type="long"/>
</composite-id>
<property name="TicketNumber" type="string" column="TICKETNUMBER" not-       null="true" />
<many-to-one class="User" name="ReservedByUser" not-null="true" unique="true"        insert="false" update="false">
<column name="USERID"></column>
</many-to-one>
<many-to-one class="Train" name="ReservedForTrain" not-null="true"        unique="true" insert="false" update="false">
<column name="TRAINID"></column>
</many-to-one>
<list table="TICKET_PASSENGERS" name="Passengers" cascade="save-update">
 <key not-null="true">
 <column name="USERID"></column>
<column name="TRAINID"></column>
</key>
<list-index column="PASSENGER_LIST_POSITION"></list-index>
<one-to-many class="Person"/>
</list>
</class>

<class name="Ticket" table="TICKET" >
<composite-id name="CompositeId" class="CompositeKey">
<key-property name="userKey" access="field" column="USERID" type="long"/>
<key-property name="trainKey" access="field" column="TRAINID" type="long"/>
</composite-id>
<property name="TicketNumber" type="string" column="TICKETNUMBER" not-       null="true" />
<many-to-one class="User" name="ReservedByUser" not-null="true" unique="true"        insert="false" update="false">
<column name="USERID"></column>
</many-to-one>
<many-to-one class="Train" name="ReservedForTrain" not-null="true"        unique="true" insert="false" update="false">
<column name="TRAINID"></column>
</many-to-one>
<list table="TICKET_PASSENGERS" name="Passengers" cascade="save-update">
<key not-null="true">
<column name="USERID"></column>
<column name="TRAINID"></column>
</key>
<list-index column="PASSENGER_LIST_POSITION"></list-index>
<one-to-many class="Person"/>
</list>
</class>

Do note the fact that for both the one-to-many associations shown in the code snippet above and in Figure 2, we have put both ends of the association of collections to be inverse (by using insert=false and update=false, inverse=true). People who have read the article series will know only one end has to be made inverse. Why both ends are made inverse here? Because we use a transaction in code (IssueTicket method) to ensure that inserts to Ticket, User, and Train tables are atomic. Also most importantly, the primary key of both tables i.e. User and Train have been made the composite key in the association class thus representing the associations and forming a composite key. Hence there is no need to automatically generate additional SQL statements on both ends of the association. So they are made inverse at both ends. The structure of this solution can be understood more clearly in Microsoft Visual Studio 2012 when you look at the structure of the table formed for the Ticket - association class. It will show the composite key made from two primary keys which are also part of the two associations very clearly. Use the downloaded code supplied in Visual Studio 2012 to observe this. This solution is good. There is another way of using the "join" table but I find this solution more appropriate and objects oriented.

The downloadable solution (Microsoft Visual Studio 2012 Trial Version) with this article contains the client code also. They are console-based projects used to show the many-to-many entity association explained here. The change to run the code is to add a service-based database to the project named RailwayReservationSystem project. The steps to do it is familiar to all but I will just describe it to complete the article: right-click on the RailwayReservationSystem project. In the popup menu that appears select "Add" then select "New Item". The wizard for adding the new item will open. In this select "Service-based Database" and click the OK button. A dialog will open later which you can cancel. Now a new database is added to your project space. Select it and you will see its properties in the properties windows of Solution Explorer. Just copy its full path and use it in the connection string for .config configuration files in the RailwayReservationSystem project and in the app. config file in the client project. We can see the Tickets, Users, and Trains persisted in the respective tables in the database you added in VS2012 quite clearly when the client project is run. Do not use the sample download project provided for experimenting with database fetches. Fetches will be covered in Article 8. For now, enjoy experimenting with the persistence of associations in objects using NHibernate. Check the persistence of Train, User, and Ticket to DB using the "SQL" menu in VS2012 and by writing a SQL query in the editor available from this menu itself.

Conclusion

It is a huge advantage to code NHibernate's many-to-many entity association exactly in the way we model it in OOAD. The reason was mentioned in the article itself. The association class used in OOAD to break the many-to-many association is not an artificial class used only for this purpose. It exists as part of every domain itself as we saw here and captures the required information precisely. The rental between houses and tenants in a rental agency system, the lease between landowners and leasees in a real estate system, many kinds of tickets in various domains, subscription plans between consumers and services by service providers in service provider systems, room booking/room occupancy between hotel rooms and occupants in hotel systems, consultation record between doctors and patients in Hospital Systems are all examples of an association class in those domains for the listed many-to-many associations. So having NHibernate map this many-to-many entity association with the respective association class for that domain is very useful. The next article 5 - B will discuss the many-to-many entity associations in our sample scenario. Enjoy NHibernate.

Reference

To gain a more comprehensive understanding of the subject please read the next part.

• Object Relational Mapping (ORM) Using NHibernate - Part 6 of 8
• Object Relational Mapping (ORM) Using NHibernate - Part 7 of 8
• Object Relational Mapping (ORM) Using NHibernate - Part 8 of 8