L'architecture S # arp ne prend pas en charge les correspondances plusieurs à plusieurs

Question

J'ai pratiquement tout essayé pour que les mappages M: M fonctionnent dans l’architecture S # arp. Malheureusement, le projet exemple Northwind n’a pas de substitution M: M.

Tout a bien fonctionné dans mon projet avant la conversion en S # arp et son choix de mappage automatique Fluent NHibernate. J'aime l'auto-mapping, c'est bien, mais les substitutions ne semblent pas s'enregistrer.

Tout semble fonctionner en mémoire et lors des tests. Toutefois, lors de la validation des données dans une base de données, rien n'est inséré dans ma table de référence M: M.

Si nous prenons l'exemple simple d'une catégorie pouvant contenir de nombreux produits et qu'un produit pouvant figurer dans plusieurs catégories, nous aurions une table appelée CategoryProduct (je n'aime pas la pluralisation) comportant les colonnes Category_id et Product_id.

Mon modèle de persistance automatique génère en tant que tel:

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

Le remplacement de mappage pour la catégorie ressemble à ceci:

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();
    }
}

Et le produit a un remplacement de mappage en tant que tel:

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();
    }
}

J'ai essayé de nombreuses combinaisons de structuration des mappages M: M, mais rien ne fonctionne.

Cet article contient une suggestion pour compiler S # arp avec la mise à jour FHN, j’ai essayé cela, mais le dernier code FHN est très différent de celui utilisé par S # arp, semble-t-il. Tous les conflits de rupture ont été corrigés mais cela ne fonctionne toujours pas.

Espérons que quelqu'un d'autre a rencontré et résolu le problème de cartographie automatique de M: M pour éviter les problèmes liés à S # arp.

Answer 1

Géré pour résoudre le problème, il s’est avéré être une erreur de débutant S # arp.

Pour que les données de ManyToMany soient sauvegardées, l'attribut [Transaction] doit être attribué à la méthode du contrôleur.