.net - fluently - Fluido NHibernate JoinedSubClass es obsoleto

nhibernate fluent mapping

Question

Me pregunto sobre algo. Estoy sentado aquí con una solución. Tengo 1 superclase que tiene 2 subclases y estoy mapeando esto usando JoinSubClass, pero entiendo que este método es obsoleto, y dice que debería usar ClassMap y SubClassMap, pero si hago esto el AutoMapping no funciona, y no quiero eso. ¿Hay alguna solución para esto?

Aquí está la jerarquía:

public class Tag : Entity
{
public virtual string Name {get;set;}
public virtual User User {get;set;}
}
public class RespondentTag : Tag
{
public virtual IList<Respondent> Respondents {get;set;}
}
public class ArchiveTag : Tag
{
public virtual IList<Survey> Surveys {get;set;}
}

Como probablemente haya averiguado, quiero que sea una tabla por mapeo de jerarquía con subclases con listas que son muchas a muchas. Como una tabla ''Tag'', luego Tag_Respondent y Tag_Archive (para la relación de muchos a muchos).

Aquí está el mapeo que estoy usando actualmente:

public class TagMap : IAutoMappingOverride<Tag>
{
public void Override(AutoMapping<Tag> mapping)
{
//This is obsolete
mapping.JoinedSubClass("RespondentTagId", RespondentTagMap.AsJoinedSubClass());
mapping.JoinedSubClass("ArchiveTagId", ArchiveTagMap.AsJoinedSubClass());
}
}
public class RespondentTagMap
{
public static Action<JoinedSubClassPart<RespondentTag>> AsJoinedSubClass()
{
return part =>
part.HasManyToMany(x => x.RespondentList)
.Cascade
.SaveUpdate()
.Inverse()
.Table("Tag_Respondent");
}
}
public class ArchiveTagMap
{
public static Action<JoinedSubClassPart<ArchiveTag>> AsJoinedSubClass()
{
return part =>
part.HasManyToMany(x => x.Surveys)
.Cascade
.SaveUpdate()
.Inverse()
.Table("Tag_Archive");
}
}

¿Alguien sabe acerca de una solución u otra solución para resolver esto? (Sin deshabilitar la automatización)

Cualquier respuesta será apreciada.

¡Gracias por adelantado!

Answer 1

Perdónenme si estoy malinterpretando su objetivo, pero haré una puñalada porque tengo una herencia similar en mi proyecto (aunque utilizo un patrón de tabla por clase base con una columna discriminatoria).

Creo que puedes lograr lo que estás buscando hacer haciendo que FNH ignore tu clase base de Tag y luego anule la asignación en tus objetos RespondentTag y ArchiveTag para implementar la relación de muchos a muchos. Entonces, en su configuración de FNH, debe especificar un argumento para su llamada de asignaciones de:

m.AutoMappings.Add(AutoMap.AssemblyOf<SomeObjectInMyAssembly>(new MyAutoMapConfig()) // Assuming you''re using a config class
.IgnoreBase(typeof(Entity))
.IgnoreBase(typeof(Tag))
.UseOverridesFromAssemblyOf<SomeOverrideClass>());

Entonces tendría que configurar anulaciones en cualquier ensamblaje que las esté almacenando. Tendría algo como esto:

public class RespondentTagOverride : IAutoMappingOverride<RespondentTag>
{
public void Override(AutoMapping<RespondentTag> mapping)
{
mapping.HasManyToMany(x => x.RespondentList)
.Cascade
.SaveUpdate()
.Inverse()
.Table("Tag_Respondent"); // Not sure if the table call works in the override...you may have to use a convention for this
}
}

Lo mismo para el objeto ArchiveTag .

Eso es similar a lo que hago en mi esquema de herencia, aunque como mencioné, en mi clase de configuración de automaps IsDiscriminated método IsDiscriminated para indicar que mis objetos son de tabla por clase base y discriminados.