如何处理更新实体。 NHibernate + ASP.NET MVC

Question

I cannot update created previously entity. I'm getting a StaleObjectException exception with message:

Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [Project.DomainLayer.Entities.Employee#00000000-0000-0000-0000-000000000000]

I don't share the update process with anyone. What's the problem?

Data Access / DI

public class DataAccessModule : Ninject.Modules.NinjectModule
{
    public override void Load()
    {
        this.Bind<ISessionFactory>()
            .ToMethod(c => new Configuration().Configure().BuildSessionFactory())
            .InSingletonScope();

        this.Bind<ISession>()
            .ToMethod(ctx => ctx.Kernel.TryGet<ISessionFactory>().OpenSession())
            .InRequestScope();

        this.Bind(typeof(IRepository<>)).To(typeof(Repository<>))
            .InRequestScope();
    }
}

Data Access / Mappings

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Project.DomainLayer"   namespace="Project.DomainLayer.Entities">
<class name="Employee" optimistic-lock="version">
    <id name="ID" column="EmployeeID" unsaved-value="00000000-0000-0000-0000-000000000000">
        <generator class="guid.comb" />
    </id>
    <version name="Version" type="Int32" column="Version" />
    <!-- properties -->
    <property name="EmployeeNumber" />
    <!-- ... -->
    <property name="PassportRegistredOn" not-null="true" />
    <!-- sets -->
    <set name="AttachedInformation" cascade="all">
        <key column="EmployeeID" />
        <element column="Attachment" />
    </set>
    <set name="TravelVouchers" cascade="all">
        <key column="EmployeeID" />
        <one-to-many class="TravelVoucher" />
    </set>
  </class>
</hibernate-mapping>

Data Access / Repository

public class Repository<T> : IRepository<T> where T : AbstractEntity<T>, IAggregateRoot
{
    private ISession session;

    public Repository(ISession session)
    {
        this.session = session;
    }

    // other methods are omitted

    public void Update(T entity)
    {            
        using(var transaction = this.session.BeginTransaction())
        {
            this.session.Update(entity);
            transaction.Commit();
        }
    }
    public void Update(Guid id)
    {            
        using(var transaction = this.session.BeginTransaction())
        {
            this.session.Update(this.session.Load<T>(id));
            transaction.Commit();
        }
    }
} 

Inside a Controller

public class EmployeeController : Controller
{
    private IRepository<Employee> repository;

    public EmployeeController(IRepository<Employee> repository)
    {
        this.repository = repository;
    }        
    public ActionResult Edit(Guid id)
    {
        var e = repository.Load(id);
        return View(e);
    }
    [AcceptVerbs(HttpVerbs.Post)]
    public ActionResult Edit(Employee employee)
    {
        if(ModelState.IsValid)
        {
            repository.Update(employee);
            return RedirectToAction("Deatils", "Employee", new { id = employee.ID });
        }
        else
        {
            return View(employee);
        }
    }
}

How do I update my entities? Thanks!

EDIT

So I added unsaved-value="{Guid.Empty goes here}" to my markup. Moreover I've tried to do the next thing:

public void Update(T entity)
{
    using(var transaction = this.session.BeginTransaction())
    {
        try
        {
            this.session.Update(entity);
            transaction.Commit();
        }
        catch(StaleObjectStateException ex)
        {
            try
            {
                session.Merge(entity);
                transaction.Commit();
            }
            catch
            {
                transaction.Rollback();
                throw;
            }
        }

    }
}

And this gives me the same effect.. I mean transaction.Commit(); after Merge gives the same exception.

Also I'm wondering should I expose, using hidden input, the entity ID on the Edit view?

EDIT

So entity really detaches. When it passes to controller the ID equals Guid.Empty . How do I handle it, Merge or Reattach ?

Answer 1

There are two scenarios that you can run into, given your code pattern.

1. You could retrieve the object from the db using ISession.Get() which can be followed by a change/update to the retrieved object. For this change to be effective, all you need to do is flush the session or commit the transaction as Nhibernate will track all the changes for you automatically.

2. You have a transient instance, an object that is not associated with the ISession in context, from which you want to update. In this case, from my experience, the best practice is to ISession.Get() the object and make the corresponding changes to the object you just retrieve. (usually your view model is different from your domain model as well, don't mix both) This pattern is shown below. It works all the time. Make sure you also use ISession.SaveOrUpdate() .

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Edit(Employee employee)
{
    if(ModelState.IsValid)
    {
        var persistentEmployee = repository.Get(employee.Id);
        if(  persistentEmployee == null){
            throw new Exception(String.Format("Employee with Id: {0} does not exist.", employee.Id));
        }
        persistentEmployee.Name = employee.Name;
        persistentEmployee.PhoneNumber = employee.PhoneNumber;
        //and so on
        repository.Update(persistentEmployee);
        return RedirectToAction("Deatils", "Employee", new { id = employee.ID });
    }
    else
    {
        return View(employee);
    }
}

Also, notice that your controller is probably instantiated on a per-request basis, hence, the lifetime of your ISession does not span multiple calls to the different methods you have in your controller. In other words, every method is almost always working within the context of a new ISession (unit of work).

Answer 2

Your logic is not good, becouse you use domain model like Employee as ViewModel. Best practice is use CreateEmploeeViewModel and EditEmployeeViewModel and separate Domain Logic and View Model logic. For Example:

public class Employee 
 {
        public virtual int Id { get; set; }

        public virtual string FirstName { get; set; }

        public virtual string LastName { get; set; }

        public virtual string MiddleName { get; set; }
 }

public class CreateEmployeeViewModel 
 {
        public virtual string FirstName { get; set; }

        public virtual string LastName { get; set; }

        public virtual string MiddleName { get; set; }
 }

public class EditEmployeeViewModel : CreateEmployeeViewModel  
 {
        public virtual int Id { get; set; }
 }

To convert from Employee to ViewModel I prefer yo use Automapper .

So controller Actions become to looks like:

[HttpGet]
    public virtual ActionResult Edit(int id)
    {
        Employee entity = GetEntityById(id);
        EmployeeEditViewModel model = new EmployeeEditViewModel();

        Mapper.Map(source, destination);            

        return View("Edit", model);
    }

    [HttpPost]
    public virtual ActionResult Edit(EmployeeEditViewModel model)
    { 
        if (ModelState.IsValid)
        {
            Employee entity = GetEntityById(model.Id);

            entity = Mapper.Map(model, entity);               
            EntitiesRepository.Save(entity);

            return GetIndexViewActionFromEdit(model);
        }           

        return View("Edit", model);
    }

In this case NHibernate knows that you update Employee, and you can`t remove some properties which not exist in your View.

Answer 3

I believe your Employee object has become what NHibernate calls "detached" between the GET and POST of your Edit action methods. See the NHibernate documentation on this topic for more details and some solutions. In fact, the link describes the exact GET-POST scenario you seem to be using.

You may need to reattach your Employee object and/or specify the "unsaved value" as Firo suggested so that NHibernate knows an Employee with an ID of Guid.Empty has not been persisted to the database yet. Otherwise, as Firo suggested, NHibernate sees Guid.Empty as a valid ID, and thinks the object has already been saved to the database but the session in which it was retrieved has been discarded (hence, the object becoming "detached").

Hope this helps.

Answer 4

You ask,

Also I'm wondering should I expose, using hidden input, the entity ID on the Edit view?

Yes, you should. You should also expose the Version in a hidden input as its business is to help prevent concurrent edits to the same entity. The StaleObjectException hints that you've got versioning turned on, and in that case, the update will only work if the version value (Int32) that you send back is identical to the one in the database.

You can always get around it by reloading the entity and mapping it, ensuring that the Version value is likely to match, but that seems to subvert its purpose.

IMHO, I'd put the entity ID and Version in a hidden input, and on postback, reload the entity and map the data. That way, like Ivan Korytin suggests above, you would not have to carry around properties that aren't needed in your view. You can also handle the staleness at the controller level and add a validation error rather than have NHibernate tell you your object is stale.

Ivan Korytin outlines the standard process for handling a simple edit of an entity. The only issue with his answer is that it does not address the Version property. IMHO, the database should not be versioned, or the Version property should matter.

Answer 5

If you are one of us that no answer from here helped, try looking what for an "ID" in your entity is sending.

I have the same problem but in the end, I saw that I was changing the ID to another number (in NHibernate the id will be self generated, if you set it up that way! ).

So, bottom of line, check if the structure of the data that you are sending and the values, match what you are expecting to send.

Hope I can help anyone! :)

Answer 6

"unsaved value" is missing. hence NH thinks that Guid.Empty is a valid id

<id name="ID" column="EmployeeID" unsaved-value="0000000-0000-0000-0000-000000000000">

Answer 7

If you want to update some entity's fields you don't need to use session.Update(), use session.Flush() before close transaction.

session.Update() -> Update the persistent instance with the identifier of the given transient instance.

Answer 8

After all it helps, but I think it's horrible:

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Edit(Guid id, Employee employee)
{
    if(ModelState.IsValid)
    {
        var e = repository.Get(id);

        if(Guid.Empty != e.ID)
        {
            e.Department = employee.Department;
            repository.Update(employee.ID);
            return RedirectToAction("Details", "Employee", new { id = e.ID });
        }
        /*...*/
    }
}

Even if I put HiddenFor fields on Edit view for ID (and Version ) the ID being passed is ordinary a Guid.Empty which states that employee is transient.

I'm really appreciated for your help guys!

Questions

I know what viewmodels are, but quite not understood how does it help with detaching .

Why if I put TextBoxFor(e => e.ID) on Edit view it binds employee like a transient entity without saving the ID value?