Dans Fluent NHibernate, comment combinez-vous des types automatisés avec des types non automatisés?

Question

Pour le moment, je remplace mon projet par le style classique couramment utilisé, qui consiste à définir manuellement un ClassMap pour chaque entité de domaine, pour que le mappeur automatique génère automatiquement les mappages pour moi. Mais j'aimerais continuer à utiliser les classes que j'ai déjà mappées dans le style classique, jusqu'à ce que je puisse ajuster les mappages automatiques afin qu'ils correspondent aux anciens mappages classiques.

Le seul problème est que nhibernate fluent se bloque lorsque le mappeur automatique frappe une classe déjà mappée dans le style nhibernate fluent classique.

Voici mon code d'installation AutoPersistenceModel :

_autoPersistenceModel = AutoMap.AssemblyOf<DomainEntity>();
_autoPersistenceModel.AddMappingsFromAssembly(typeof (PlayerPersistenceMap).Assembly);

_autoPersistenceModel.Alterations(x =>
                    x.Add<AutoMappingAlteration>())
                .Setup(s =>
                {
                    s.FindIdentity = type => type.Name == "ID";

                    s.IsBaseType = type => (type == typeof(DomainEntity));
                })
                .Conventions
                    .AddFromAssemblyOf<IdentityColumnConvention>()
                    .UseOverridesFromAssemblyOf<PlayerMappingOverride>();

Quelqu'un peut-il m'aider ici?

Plus d'infos:

J'ai également essayé la technique mentionnée sur le wiki "fluent-nhibernate" ici . Hélas, je reçois toujours l’erreur suivante: Mappage de classe / entité en double .

Answer 1

Le exemple de mappages couramment utilisés et de mappages automatiques sur le wiki devrait fonctionner, si cela ne fonctionne pas. alors il y a un bug.

Comme solution de contournement, excluez les types qui ont été mappés manuellement de vos automappings. Pour ce faire, utilisez la méthode Where , comme le montrent les exemples du wiki, à peu près comme ceci:

AutoMap.AssemblyOf<DomainEntity>()
  .Where(type => type != typeof(OneOfYourManuallyMappedClasses));

Si vous avez beaucoup de correspondances fluides, vous pouvez créer une collection pour garder la configuration de l'auto-mapping propre:

var mappedTypes = new[] { typeof(One), typeof(Two) };

AutoMap.AssemblyOf<DomainEntity>()
  .Where(type => !mappedTypes.Contains(type));

Encore une fois, cela ne devrait pas être nécessaire, mais si vous êtes certain que cela ne fonctionne pas avec l'exemple du wiki, alors je vous suggère de soulever un problème.