¿Cómo puedo cambiar el padre de un niño en NHibernate cuando cascade es delete-all-huphan?

nhibernate-mapping

Question

Tengo dos entidades en una relación bidireccional de uno a muchos:

public class Storage
{
public IList<Box> Boxes { get; set; }
}
public class Box
{
public Storage CurrentStorage { get; set; }
}

Y el mapeo:

<class name="Storage">
<bag name="Boxes" cascade="all-delete-orphan" inverse="true">
<key column="Storage_Id" />
<one-to-many class="Box" />
</bag>
</class>
<class name="Box">
<many-to-one name="CurrentStorage" column="Storage_Id" />
</class>

Un Storage puede tener muchas Boxes , pero una Box solo puede pertenecer a un Storage . Los he mapeado para que el uno-a-muchos tenga una cascada de all-delete-orphan .

Mi problema surge cuando trato de cambiar el Storage una Caja. Asumiendo que ya ejecuté este código:

var storage1 = new Storage();
var storage2 = new Storage();
storage1.Boxes.Add(new Box());
Session.Create(storage1);
Session.Create(storage2);

El siguiente código me dará una excepción:

// get the first and only box in the DB
var existingBox = Database.GetBox().First();
// remove the box from storage1
existingBox.CurrentStorage.Boxes.Remove(existingBox);
// add the box to storage2 after it''s been removed from storage1
var storage2 = Database.GetStorage().Second();
storage2.Boxes.Add(existingBox);
Session.Flush(); // commit changes to DB

Obtengo la siguiente excepción:

NHibernate.ObjectDeletedException: el objeto eliminado se volvería a guardar por cascada (eliminar el objeto eliminado de las asociaciones)

Esta excepción se produce porque tengo el conjunto de cascadas para all-delete-orphan . El primer Storage detectó que eliminé el Box de su colección y lo marqué para su eliminación. Sin embargo, cuando lo agregué al segundo Storage (en la misma sesión), intenta guardar el cuadro nuevamente y se lanza ObjectDeletedException .

Mi pregunta es, ¿cómo consigo que el Box cambie su Storage principal sin encontrar esta excepción? Sé que una solución posible es cambiar la cascada a all , pero luego pierdo la capacidad de que NHibernate elimine automáticamente un Box simplemente quitándolo de un Storage y no reasociándolo con otro. ¿O es esta la única forma de hacerlo y tengo que llamar manualmente a Session.Delete en el cuadro para eliminarlo?

Answer 1

Ver http://fabiomaulo.blogspot.com/2009/09/nhibernate-tree-re-parenting.html

Básicamente, se reduce a esto ... Necesita definir un tipo de colección personalizada para NHibernate que redefine lo que significa ser huérfano. El comportamiento predeterminado de NHibernate es hacer exactamente lo que descubrió: considerar que un niño queda huérfano si se lo quitó del padre. En su lugar, necesita NHibernate para probar al niño para ver si ha sido asignado a un nuevo padre. NHibernate no hace esto de forma predeterminada porque requeriría información adicional sobre la asignación de uno a muchos: necesitaría conocer el nombre de la propiedad de muchos a uno correspondiente en el elemento secundario.

Cambie su asignación de Storage para que se vea así:

<class name="Storage">
<bag name="Boxes" cascade="all-delete-orphan" inverse="true" collection-type="StorageBoxBag">
<key column="Storage_Id" />
<one-to-many class="Box" />
</bag>
</class>

Defina un nuevo tipo denominado StorageBoxBag (nota: este código está escrito contra NHibernate 2.1). Si está utilizando NH3, puede que tenga que ajustarlo un poco):

public class StorageBoxBag : IUserCollectionType
{
public object Instantiate(int anticipatedSize)
{
return new List<Box>();
}
public IPersistentCollection Instantiate(ISessionImplementor session, ICollectionPersister persister)
{
return new PersistentStorageBoxBag(session);
}
public IPersistentCollection Wrap(ISessionImplementor session, object collection)
{
return new PersistentStorageBoxBag(session, (IList<Box>)collection);
}
public IEnumerable GetElements(object collection)
{
return (IEnumerable)collection;
}
public bool Contains(object collection, object entity)
{
return ((IList<Box>)collection).Contains((Box)entity);
}
public object IndexOf(object collection, object entity)
{
return ((IList<Box>) collection).IndexOf((Box) entity);
}
public object ReplaceElements(object original, object target, ICollectionPersister persister, object owner, IDictionary copyCache, ISessionImplementor session)
{
var result = (IList<Box>)target;
result.Clear();
foreach (var box in (IEnumerable)original)
result.Add((Box)box);
return result;
}
}

... y un nuevo tipo llamado PersistentStorageBoxBag :

public class PersistentStorageBoxBag: PersistentGenericBag<Box>
{
public PersistentStorageBoxBag(ISessionImplementor session)
: base(session)
{
}
public PersistentStorageBoxBag(ISessionImplementor session, ICollection<Box> original)
: base(session, original)
{
}
public override ICollection GetOrphans(object snapshot, string entityName)
{
var orphans = base.GetOrphans(snapshot, entityName)
.Cast<Box>()
.Where(b => ReferenceEquals(null, b.CurrentStorage))
.ToArray();
return orphans;
}
}

El método GetOrphans es donde ocurre la magia. Pedimos a NHibernate la lista de Box que cree que son huérfanos, y luego la filtramos solo al conjunto de Box que en realidad son huérfanos.