Wie ordnet man eine Aufzählung als int-Wert mit fließendem NHibernate zu?

Die Frage sagt wirklich alles, die Standardeinstellung ist, dass es als ein zugeordnet wird, stringaber ich brauche es, um es als zuzuordnen int.

Ich verwende derzeit PersistenceModelzum Festlegen meiner Konventionen, wenn dies einen Unterschied macht. Danke im Voraus.

Update Ich habe festgestellt, dass das Aufrufen der neuesten Version des Codes aus dem Trunk meine Probleme gelöst hat.

Die Art und Weise, diese Konvention zu definieren, hat sich vor einiger Zeit geändert.

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

Wie bereits erwähnt, brachte mich die neueste Version von Fluent NHibernate aus dem Kofferraum, wo ich sein musste. Eine Beispielzuordnung für eine Aufzählung mit dem neuesten Code lautet:

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

Der benutzerdefinierte Typ erzwingt, dass er als Instanz der Aufzählung behandelt wird, anstatt die zu verwenden GenericEnumMapper<TEnum>.

Ich denke tatsächlich darüber nach, einen Patch einzureichen, um zwischen einem Enum-Mapper, der eine Zeichenfolge beibehält, und einem, der ein Int beibehält, wechseln zu können, da dies etwas zu sein scheint, das Sie als Konvention festlegen sollten.

Dies tauchte in meiner letzten Aktivität auf und in den neueren Versionen von Fluent NHibernate haben sich die Dinge geändert, um dies zu vereinfachen.

Um alle Aufzählungen als Ganzzahlen zuzuordnen, können Sie jetzt eine Konvention wie folgt erstellen:

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

Dann muss Ihr Mapping nur noch sein:

Map(quote => quote.Status);

Sie fügen die Konvention wie folgt zu Ihrer Fluent NHibernate-Zuordnung hinzu.

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

Vergessen Sie nicht nullbare Aufzählungen (wie ExampleEnum? ExampleProperty)! Sie müssen separat geprüft werden. So wird es mit der neuen Konfiguration im FNH-Stil gemacht:

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

So habe ich eine enum-Eigenschaft mit einem int-Wert zugeordnet:

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

funktioniert bei mir!

Für Benutzer von Fluent NHibernate mit Automapping (und möglicherweise einem IoC-Container):

Das IUserTypeConventionist wie @ Julien ‚s Antwort oben: 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);
    }
}

Die Konfiguration von Fluent NHibernate Automapping kann folgendermaßen konfiguriert werden:

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

* Dann CreateSessionFactorykann das problemlos in einem IoC wie Castle Windsor (mit PersistenceFacility und Installer) verwendet werden. * *

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

Sie können ein NHibernate erstellen IUserTypeund es CustomTypeIs<T>()in der Eigenschaftskarte angeben .

Sie sollten die Werte als int / tinyint in Ihrer DB-Tabelle beibehalten. Um Ihre Aufzählung zuzuordnen, müssen Sie die Zuordnung korrekt angeben. Bitte sehen Sie unten Mapping und Enum-Beispiel,

Mapping-Klasse

öffentliche Klasse TransactionMap: ClassMap-Transaktion
{
    öffentliche TransactionMap ()
    {
        // Andere Zuordnungen
        ..... .....
        // Mapping für Enum
        Map (x => x.Status, "Status"). CustomType ();

        Tabelle ("Transaktion");
    }}
}}

Aufzählung

öffentliche Aufzählung TransactionStatus
{
   Warten = 1,
   Verarbeitet = 2,
   RolledBack = 3,
   Blockiert = 4,
   Rückerstattung = 5,
   Bereits verarbeitet = 6,
}}