NHibernate
The object-relational mapper for .NET
What can I do if instead of physically delete a record in the database I just want to mark it as deleted?
There are at least two possibilities to achieve the desired result
Let's assume a simple order entry system with just two entities Order and OrderLine.
Note: the implementation of the IdentityFieldProvider class I have discussed here.
The business requirements are such as that you are not allowed to physically delete an order from the system but just mark it as deleted in case where the user cancels an order. That's the reason why we have a property IsDeleted in the two entities. When querying for orders the system will (automatically) filter out orders having IsDeleted=true.
Let's have a look at the implementation of the Order and OrderLine entities. (Note: I have only implemented the absolute minimum needed for this sample to work. A realistic order entity would be more complex.)
public class Order : IdentityFieldProvider<Order>
{
public virtual string CustomerName { get; set; }
public virtual DateTime OrderDate { get; set; }
public virtual bool IsDeleted { get; set; }
public virtual ISet<OrderLine> OrderLines { get; set; }
public Order()
{
OrderLines = new HashedSet<OrderLine>();
}
}
public class OrderLine : IdentityFieldProvider<OrderLine>
{
public virtual string ProductName { get; set; }
public virtual int Amount { get; set; }
public virtual bool IsDeleted { get; set; }
}
And here are the mappings (For this sample I have the mapping of both entities in a single XML file although the recommendations are one mapping per entity)
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
assembly="Domain"
namespace="Domain"
schema="Playground">
<class name="Order" table="Orders" where="IsDeleted=0">
<id name="Id">
<generator class="guid"/>
</id>
<property name="CustomerName" not-null="true" length="50"/>
<property name="OrderDate" not-null="true"/>
<property name="IsDeleted" not-null="true"/>
<set name="OrderLines" cascade="all-delete-orphan">
<key column="OrderId"/>
<one-to-many class="OrderLine"/>
</set>
</class>
<class name="OrderLine" where="IsDeleted=0">
<id name="Id">
<generator class="guid"/>
</id>
<property name="ProductName" not-null="true" length="50"/>
<property name="Amount" not-null="true"/>
<property name="IsDeleted" not-null="true"/>
</class>
</hibernate-mapping>
Note the where attribute on the <class> tag of the order mapping. This contains a filter to avoid that NHibernate returns orders marked as deleted when you query for orders.
This is easy. Assume that we have a OrderRepository class with a Remove method which physically deletes the order from the system and a SoftDelete method witch only logically removes the order from the system.
The implementation of the Remove method would probably look similar to this
public void Remove(Order order)
{
using (ISession session = SessionFactory.OpenSession())
{
using (ITransaction tx = session.BeginTransaction())
{
session.Delete(order);
tx.Commit();
}
}
}
and the SQL generated by NHibernate is as follows
NHibernate: UPDATE Playground.OrderLine SET OrderId = null WHERE OrderId = @p0; @p0 = '34e04bfd-18d2-4451-8673-b98466c6260f'
NHibernate: DELETE FROM Playground.OrderLine WHERE Id = @p0; @p0 = '82b6ba92-9eca-494e-a71f-10a2fa0012db'
NHibernate: DELETE FROM Playground.OrderLine WHERE Id = @p0; @p0 = 'bec15bd1-1216-4623-bfd9-1319fbef764b'
NHibernate: DELETE FROM Playground.Orders WHERE Id = @p0; @p0 = '34e04bfd-18d2-4451-8673-b98466c6260f'
This causes an Order (and its set of OrderLine items) to be physically deleted from the system. Note that I'm using SQL Server 2005 as database and my tables are in the Schema called 'Playground'.
Now for a soft delete we could write in the repository something like this
public void SoftDelete(Order order)
{
using (ISession session = SessionFactory.OpenSession())
{
using (ITransaction tx = session.BeginTransaction())
{
order.IsDeleted = true;
session.Update(order);
tx.Commit();
}
}
}
Note that I have implemented the IsDeleted property of the Order entity such as that it propagates changes to its OrderLine children (only if IsDeleted is set to true).
private bool _isDeleted;
public virtual bool IsDeleted
{
get { return _isDeleted; }
set
{
_isDeleted = value;
if (_isDeleted)
{
foreach (var line in OrderLines)
{
line.IsDeleted = true;
}
}
}
}
and the SQL generated by NHibernate is similar to this
NHibernate: UPDATE Playground.Orders SET CustomerName = @p0,
OrderDate = @p1, IsDeleted = @p2 WHERE Id = @p3; @p0 = 'IBM',
@p1 = '09.04.2008 00:00:00', @p2 = 'True',
@p3 = '14bd85fd-0094-446b-8416-953e158747a1'
NHibernate: UPDATE Playground.OrderLine SET ProductName = @p0,
Amount = @p1, IsDeleted = @p2 WHERE Id = @p3; @p0 = 'Intel Dual Core CPU A',
@p1 = '1', @p2 = 'True', @p3 = 'fd274287-22a0-460f-a2f1-42cdb031000c'
NHibernate: UPDATE Playground.OrderLine SET ProductName = @p0,
Amount = @p1, IsDeleted = @p2 WHERE Id = @p3; @p0 = 'Intel Dual Core CPU B',
@p1 = '1', @p2 = 'True', @p3 = 'ec714db7-61e2-4d64-a532-d05da5b8c5af'
As expected the records are not deleted in the database but the order and its order lines are marked as deleted.
If you want a more generic approach you'll have to write a DeleteEvent Listener and register it with the NHibernate configuration. You can argue that "soft delete" is a cross cutting concern and as such should not be implemented in the repositories.
This approach is a little bit more involved and you need some intimate knowledge of the inner workings of NHibernate. Events and Event Listeners are a new concept introduced in NHibernate 2.0. Unfortunately this also means that there is not much help or description around at the moment. But the concept is very powerful! What you can do is only limited by your imagination...
A starting point would be to define a class e.g. called MyDeleteEventListener which inherits from the DefaultDeleteEventListener class implemented in NHibernate. Then you override e.g. the DeleteEntity method and define your own "delete" logic.
The code might look similar to this (many thanks for help to Will Shaver)
public class MyDeleteEventListener : DefaultDeleteEventListener
{
protected override void DeleteEntity(IEventSource session, object entity,
EntityEntry entityEntry, bool isCascadeDeleteEnabled,
IEntityPersister persister, ISet transientEntities)
{
if (entity is ISoftDeletable)
{
var e = (ISoftDeletable)entity;
e.IsDeleted = true;
CascadeBeforeDelete(session, persister, entity, entityEntry, transientEntities);
CascadeAfterDelete(session, persister, entity, transientEntities);
}
else
{
base.DeleteEntity(session, entity, entityEntry, isCascadeDeleteEnabled,
persister, transientEntities);
}
}
}
Here I assume that each entity which should be "soft deleted" has to implement a special interface ISoftDeletable which is defined as follows
public interface ISoftDeletable
{
bool IsDeleted { get; set; }
}
The code in the overriden DeleteEntity method first checks whether the entity implements this interface. If NOT then the call is just forwarded to the base class for default execution (that is the entity will be physically deleted from the system). But if the entity implements the interface then we set its property IsDeleted to true, call the CascadeBeforeDelete and CascadeAfterDelete methods of the base class and are done.
Now you have to register this class with your NHibernate configuration
_configuration = new Configuration();
_configuration.Configure();
// register the DeleteEvent Listener
_configuration.SetListener(ListenerType.Delete, new MyDeleteEventListener());
_configuration.AddAssembly(Assembly.Load(new AssemblyName("DataLayer")));
_sessionFactory = _configuration.BuildSessionFactory();
If you create initial data for your tests like this
private void CreateInitialData()
{
_order = new Order {CustomerName = "IBM", OrderDate = DateTime.Today};
_orderLine1 = new OrderLine { Amount = 1, ProductName = "Intel Dual Core CPU A" };
_orderLine2 = new OrderLine { Amount = 1, ProductName = "Intel Dual Core CPU B" };
_order.OrderLines.Add(_orderLine1);
_order.OrderLines.Add(_orderLine2);
using (ISession session = SessionFactory.OpenSession())
using (ITransaction tx = session.BeginTransaction())
{
session.Save(_order);
tx.Commit();
}
}
When running a unit test like this
[Test]
public void DeleteEventListener_intercepts_delete_request_for_order()
{
Order orderToDelete;
using(ISession session = SessionFactory.OpenSession())
using (ITransaction tx = session.BeginTransaction())
{
orderToDelete = session.Get<Order>(_order.Id);
Assert.IsNotNull(orderToDelete);
Assert.AreNotSame(_order, orderToDelete);
Assert.AreEqual(_order.OrderLines.Count, orderToDelete.OrderLines.Count);
session.Delete(orderToDelete);
tx.Commit();
}
using (ISession session = SessionFactory.OpenSession())
Assert.IsNull(session.Get<Order>(orderToDelete.Id));
}
the SQL sent to the database will be similar to this
NHibernate: UPDATE Playground.Orders SET CustomerName = @p0, OrderDate = @p1,
IsDeleted = @p2 WHERE Id = @p3; @p0 = 'IBM', @p1 = '10.04.2008 00:00:00',
@p2 = 'True', @p3 = 'd51345d3-234e-4d7f-90cc-00f7767ae15f'
NHibernate: UPDATE Playground.OrderLine SET ProductName = @p0, Amount = @p1,
IsDeleted = @p2 WHERE Id = @p3; @p0 = 'Intel Dual Core CPU A', @p1 = '1',
@p2 = 'True', @p3 = 'dbfe4468-9c03-4bfe-8520-0a52312b72a8'
NHibernate: UPDATE Playground.OrderLine SET ProductName = @p0, Amount = @p1,
IsDeleted = @p2 WHERE Id = @p3; @p0 = 'Intel Dual Core CPU B', @p1 = '1',
@p2 = 'True', @p3 = '06561137-2060-46ef-a331-491dfdac705c'
Note that when using a DeleteEvent listener you don't have to implement any cascading logic for the IsDeleted property in the Order (as opposed to the "manual" case where you put your logic in the repository). The IsDeleted property can be simply implemented like this
public virtual bool IsDeleted { get; set; }
I have show two ways how to fulfill the business requirement not to physically delete an entity from the system but rather mark it as deleted when the application requests deletion of an entity. The first one is done "manually" in the repository for the respective entity or aggregate. The second one is using the concept of event listeners which is new to NHibernate and needs some intimate knowledge on the internal workings of NHibernate.
The second approach has the advantage that the business requirement of "soft deletes" is treated as a cross cutting concern and the solution presented is a generic one.
.