La anulación de mapeo muchos a muchos de la arquitectura S # arp no funciona

Question

He intentado casi todo para que las asignaciones de M: M funcionen en S # arp Architecture. Lamentablemente, el proyecto de ejemplo Northwind no tiene una anulación M: M.

Todo funcionó bien en mi proyecto antes de convertir a S # arp y su elección del mapeo automático de Fluent NHibernate. Me gusta el mapeo automático, es bueno, sin embargo, las anulaciones no parecen registrarse.

Todo parece funcionar en la memoria y en las pruebas, sin embargo, al enviar datos a una base de datos, nada se inserta en mi tabla de referencia M: M.

Si tomamos la muestra simple de una Categoría puede tener muchos Productos y un Producto puede estar en muchas Categorías, tendríamos una tabla llamada CategoryProduct (no me gusta la pluralización) que tiene columnas Category_id y Product_id.

Mi modelo de persistencia automática genera como tal:

return AutoPersistenceModel
    .MapEntitiesFromAssemblyOf<Category>()
    .Where(GetAutoMappingFilter)
    .ConventionDiscovery.Setup(GetConventions())
    .WithSetup(GetSetup())
    .UseOverridesFromAssemblyOf<AutoPersistenceModelGenerator>();

La anulación de asignación para la categoría se ve así:

public class CategoryMap : IAutoMappingOverride<Category>
{
    public void Override(AutoMap<Category> mapping)
    {
        mapping.Id(x => x.Id, "Id")
            .WithUnsavedValue(0)
            .GeneratedBy.Identity();

        mapping.Map(x => x.Name).WithLengthOf(50);

        mapping.Map(x => x.Depth);

        mapping.HasMany<Category>(x => x.Children)
            .Cascade.All()
            .KeyColumnNames.Add("Parent_id")
            .AsBag()
            .LazyLoad();

        mapping.HasManyToMany<Posting>(x => x.Products)
            .WithTableName("CategoryProduct")
            .WithParentKeyColumn("Category_id")
            .WithChildKeyColumn("Product_id")
            .Cascade.All()
            .AsBag();
    }
}

Y el Producto tiene una anulación de mapeo como tal:

public class ProductMap : IAutoMappingOverride<Product>
{
    public void Override(AutoMap<Product> mapping)
    {
        mapping.Id(x => x.Id, "Id")
            .WithUnsavedValue(0)
            .GeneratedBy.Identity();

        mapping.Map(x => x.Title).WithLengthOf(100);
        mapping.Map(x => x.Price);
        mapping.Map(x => x.Description).CustomSqlTypeIs("Text");
        mapping.References(x => x.Category).Cascade.All();

        mapping.HasMany<ProductImage>(x => x.Images).Inverse().Cascade.All().LazyLoad();

        mapping.HasManyToMany<Category>(x => x.Categories)
            .WithTableName("CategoryProduct")
            .WithParentKeyColumn("Product_id")
            .WithChildKeyColumn("Category_id")
            .Inverse()
            .AsBag();
    }
}

He intentado muchas combinaciones de estructuración de las asignaciones M: M, pero nada funciona.

Este artículo tiene sugerencias para volver compile S # arp con la actualización de FHN. Intenté esto, sin embargo, el último código de FHN es muy diferente al utilizado por S # arp. Se corrigieron todos los conflictos de ruptura pero aún no funciona.

Esperemos que alguien más haya encontrado y resuelto problemas de anulación de mapeo automático M: M con S # arp.

Answer 1

Gestionado para resolver el problema, resultó ser un error de principiantes S # arp.

Para guardar muchos datos de ManyToMany, el método del controlador debe tener asignado el atributo [Transacción].