¿Cómo se asigna una enumeración como un valor int con fluidez NHibernate?

La pregunta lo dice todo realmente, el valor predeterminado es que se asigne como un mapa, stringpero necesito que se asigne como int.

Actualmente estoy usando PersistenceModelpara establecer mis convenciones si eso hace alguna diferencia. Gracias por adelantado.

Actualización Descubrí que obtener la última versión del código desde el maletero resolvió mis problemas.

La forma de definir esta convención cambió a veces, ahora es:

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

Entonces, como se mencionó, obtener la última versión de Fluent NHibernate del maletero me llevó a donde tenía que estar. Un ejemplo de mapeo para una enumeración con el último código es:

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

El tipo personalizado obliga a que se maneje como una instancia de la enumeración en lugar de usar GenericEnumMapper<TEnum>.

De hecho, estoy considerando enviar un parche para poder cambiar entre un mapeador de enumeración que persiste una cadena y uno que persiste un int, ya que parece algo que debería poder establecer como una convención.

Esto apareció en mi actividad reciente y las cosas han cambiado en las versiones más nuevas de Fluent NHibernate para facilitar esto.

Para hacer que todas las enumeraciones se mapeen como números enteros, ahora puede crear una convención 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;
    }
}

Entonces tu mapeo solo tiene que ser:

Map(quote => quote.Status);

Agrega la convención a su mapeo Fluent NHibernate así;

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

¡No te olvides de las enumeraciones que aceptan valores NULL (como ExampleEnum? ExampleProperty)! Deben comprobarse por separado. Así es como se hace con la nueva configuración 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);
    }
}

así es como he mapeado una propiedad enum con un valor int:

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

¡funciona para mi!

Para aquellos que usan Fluent NHibernate con Automapping (y potencialmente un contenedor de IoC):

El IUserTypeConventiones tan @ Julien respuesta 's arriba: 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);
    }
}

La configuración de Fluent NHibernate Automapping podría configurarse así:

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

* Luego, CreateSessionFactoryse puede utilizar en un IoC como Castle Windsor (usando un PersistenceFacility y un instalador) fácilmente. *

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

Puede crear un NHibernate IUserTypey especificarlo usando CustomTypeIs<T>()en el mapa de propiedades.

Debe mantener los valores como int / tinyint en su tabla de base de datos. Para mapear su enumeración, debe especificar el mapeo correctamente. Consulte la siguiente muestra de mapeo y enumeración,

Clase de mapeo

TransactionMap de clase pública: Transacción de ClassMap
{
    TransactionMap público ()
    {
        // Otras asignaciones
        .....
        // Mapeo de enumeración
        Mapa (x => x.Status, "Estado"). CustomType ();

        Tabla ("Transacción");
    }
}

Enum

Public enum TransactionStatus
{
   Esperando = 1,
   Procesado = 2,
   RolledBack = 3,
   Bloqueado = 4,
   Reembolsado = 5,
   AlreadyProcessed = 6,
}