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

Question

En ce moment, je suis en train de faire passer mon projet du style classique de nhibernate fluent qui consiste à définir manuellement un fichier de type ClassMap pour chaque entité de domaine, pour que l'auto-mapper génère automatiquement les mappings 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 modifier les mappages automatiques pour qu'ils correspondent aux anciens mappages classiques.

Le seul problème est que fluent nhibernate se plante lorsque le mappeur automatique rencontre une classe qui a déjà été mappée dans le style classique de fluent nhibernate.

Voici mon AutoPersistenceModel code de configuration :

_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 ?

Plus d'informations :

J'ai également essayé la technique mentionnée sur le wiki fluent-nhibernate aquí . Hélas, je reçois toujours l'erreur : Duplicate class/entity mapping .

Answer 1

En exemple de mappings fluents mixtes et de mappings automatiques dans le wiki devrait fonctionner, si ce n'est pas le cas, il y a un bug.

Comme solution de rechange, excluez les types qui ont été mappés manuellement de vos mappages automatiques. Pour ce faire, utilisez l'option Where comme indiqué dans les exemples du wiki, quelque chose comme ceci :

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

Si vous avez beaucoup de mappings fluents, vous pouvez créer une collection pour garder la configuration de l'automapping 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 wiki, je vous suggère de soulever un problème.