Como você mapeia um enum como um valor int com NHibernate fluente?

A questão diz tudo, o padrão é mapear como um, stringmas eu preciso mapear como um int.

Atualmente estou usando PersistenceModelpara definir minhas convenções, se isso fizer alguma diferença. Desde já, obrigado.

Atualização Descobriu que obter a versão mais recente do código do tronco resolveu meus problemas.

A maneira de definir essa convenção mudou algumas vezes atrás, é agora:

public class EnumConvention : IUserTypeConvention
{
    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
        criteria.Expect(x => x.Property.PropertyType.IsEnum);
    }

    public void Apply(IPropertyInstance target)
    {
        target.CustomType(target.Property.PropertyType);
    }
}

Então, como mencionei, tirar a versão mais recente do Fluent NHibernate do porta-malas me levou aonde eu precisava estar. Um exemplo de mapeamento para um enum com o código mais recente é:

Map(quote => quote.Status).CustomTypeIs(typeof(QuoteStatus));

O tipo personalizado força-o a ser tratado como uma instância do enum em vez de usar o GenericEnumMapper<TEnum>.

Na verdade, estou pensando em enviar um patch para poder alterar entre um mapeador enum que persiste uma string e um que persiste um int, pois isso parece algo que você deve ser capaz de definir como uma convenção.

Isso apareceu na minha atividade recente e as coisas mudaram nas versões mais recentes do Fluent NHibernate para tornar isso mais fácil.

Para fazer com que todos os enums sejam mapeados como inteiros, agora você pode criar uma convenção como esta:

public class EnumConvention : IUserTypeConvention
{
    public bool Accept(IProperty target)
    {
        return target.PropertyType.IsEnum;
    }

    public void Apply(IProperty target)
    {
        target.CustomTypeIs(target.PropertyType);
    }

    public bool Accept(Type type)
    {
        return type.IsEnum;
    }
}

Então, seu mapeamento só precisa ser:

Map(quote => quote.Status);

Você adiciona a convenção ao seu mapeamento do Fluent NHibernate assim;

Fluently.Configure(nHibConfig)
    .Mappings(mappingConfiguration =>
    {
        mappingConfiguration.FluentMappings
            .ConventionDiscovery.AddFromAssemblyOf<EnumConvention>();
    })
    ./* other configuration */

Não se esqueça dos enums anuláveis ​​(como ExampleEnum? ExampleProperty)! Eles precisam ser verificados separadamente. É assim que é feito com a nova configuração de estilo FNH:

public class EnumConvention : IUserTypeConvention
{
    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
        criteria.Expect(x => x.Property.PropertyType.IsEnum ||
            (x.Property.PropertyType.IsGenericType && 
             x.Property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>) &&
             x.Property.PropertyType.GetGenericArguments()[0].IsEnum)
            );
    }

    public void Apply(IPropertyInstance target)
    {
        target.CustomType(target.Property.PropertyType);
    }
}

foi assim que mapeei uma propriedade enum com um valor int:

Map(x => x.Status).CustomType(typeof(Int32));

funciona para mim!

Para aqueles que usam o Fluent NHibernate com Automapping (e potencialmente um contêiner IoC):

Essa IUserTypeConventioné a resposta de @ Julien acima: https://stackoverflow.com/a/1706462/878612

public class EnumConvention : IUserTypeConvention
{
    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
        criteria.Expect(x => x.Property.PropertyType.IsEnum);
    }

    public void Apply(IPropertyInstance target)
    {
        target.CustomType(target.Property.PropertyType);
    }
}

A configuração de Automapeamento Fluent NHibernate pode ser configurada assim:

    protected virtual ISessionFactory CreateSessionFactory()
    {
        return Fluently.Configure()
            .Database(SetupDatabase)
            .Mappings(mappingConfiguration =>
                {
                    mappingConfiguration.AutoMappings
                        .Add(CreateAutomappings);
                }
            ).BuildSessionFactory();
    }

    protected virtual IPersistenceConfigurer SetupDatabase()
    {
        return MsSqlConfiguration.MsSql2008.UseOuterJoin()
        .ConnectionString(x => 
             x.FromConnectionStringWithKey("AppDatabase")) // In Web.config
        .ShowSql();
    }

    protected static AutoPersistenceModel CreateAutomappings()
    {
        return AutoMap.AssemblyOf<ClassInAnAssemblyToBeMapped>(
            new EntityAutomapConfiguration())
            .Conventions.Setup(c =>
                {
                    // Other IUserTypeConvention classes here
                    c.Add<EnumConvention>();
                });
    }

* Então, o CreateSessionFactorypode ser utilizado em um IoC como o Castle Windsor (usando um PersistenceFacility e instalador) facilmente. *

    Kernel.Register(
        Component.For<ISessionFactory>()
            .UsingFactoryMethod(() => CreateSessionFactory()),
            Component.For<ISession>()
            .UsingFactoryMethod(k => k.Resolve<ISessionFactory>().OpenSession())
            .LifestylePerWebRequest() 
    );

Você pode criar um NHibernate IUserTypee especificá-lo usando CustomTypeIs<T>()no mapa de propriedades.

Você deve manter os valores int / tinyint em sua tabela de banco de dados. Para mapear seu enum, você precisa especificar o mapeamento corretamente. Por favor, veja o mapeamento abaixo e a amostra de enum,

Classe de Mapeamento

public class TransactionMap: ClassMap Transaction
{
    public TransactionMap ()
    {
        // Outros mapeamentos
        .....
        // Mapeamento para enum
        Map (x => x.Status, "Status"). CustomType ();

        Tabela ("Transação");
    }
}

Enum

public enum TransactionStatus
{
   Esperando = 1,
   Processado = 2,
   RolledBack = 3,
   Bloqueado = 4,
   Reembolsado = 5,
   Já processado = 6,
}