Comment avez-vous carte un enum comme une valeur int avec NHibernate fluent?

Question dit tout, vraiment, la valeur par défaut est à la carte comme un string mais j'en ai besoin pour carte comme un int.

Je suis actuellement à l'aide PersistenceModel pour le réglage de mon conventions si cela fait une différence. Merci à l'avance.

Mise à jour
Constaté que l'obtention sur la dernière version du code à partir du tronc résolu mes malheurs.

si vous avez résolu le problème vous-même, vous devez répondre, puis marquez-le comme la réponse correcte afin de futurs chercheurs vont le trouver.
Pouvez-vous s'il vous plaît poster la réponse?
Fait les gars. Désolé pour le retard. Je n'étais pas vraiment sûr de ce que j'étais censé le faire avec une question qui a été plus d'une non-question que j'ai juste besoin de la dernière version des bibliothèques.
De la nourriture pour les robots de google: j'ai été faire "illégale d'accès pour le chargement de la collection" avant de mettre en œuvre ce pour mon enum cartographie.

InformationsquelleAutor Garry Shutler | 2009-01-13

fluent-nhibernate nhibernate

83

La façon de définir la présente convention changé parfois, il ya, c'est maintenant :
```
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);
    }
}
```
- C'est la bonne réponse pour la version la plus récente de fluent nhibernate
- Bump. ^^ Ce que Sean a dit.
- Merci, je souhaite que ce pourrait être la accepté de répondre maintenant.
- Il semble que ça fonctionne très bien pour tous les types enum, mais si vous voulez un peu comme des chaînes de caractères et d'autres comme ints? Je pense que ce doit être configurable à l'établissement de la cartographie de niveau.
- Voir la réponse de @SztupY ci-dessous qui s'étend ce afin de permettre nullable des enums. stackoverflow.com/questions/439003/...
InformationsquelleAutor Julien
45

Donc, comme mentionné, l'obtention de la dernière version de NHibernate Fluent hors du tronc, m'a amené à l'endroit où je devais être. Un exemple de cartographie pour un enum avec le code le plus récent est:
```
Map(quote => quote.Status).CustomTypeIs(typeof(QuoteStatus));
```
Le type personnalisé forces qu'il soit géré comme une instance de l'enum plutôt que d'utiliser le GenericEnumMapper<TEnum>.

En fait, je suis envisagent de soumettre un patch pour être en mesure de changer entre un enum mappeur qui persiste, une chaîne et un qui persiste int comme cela semble être quelque chose que vous devriez être en mesure de la définir comme une convention.

Ce surgi sur mon activité récente et les choses ont changé dans les versions plus récentes de Fluent NHibernate pour rendre cela plus facile.

De faire toutes les énumérations être mappé comme des entiers, vous pouvez maintenant créer une convention comme suit:
```
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;
    }
}
```
Alors votre cartographie ne doit être:
```
Map(quote => quote.Status);
```
Vous ajouter à la convention de vos Couramment NHibernate cartographie comme;
```
Fluently.Configure(nHibConfig)
    .Mappings(mappingConfiguration =>
    {
        mappingConfiguration.FluentMappings
            .ConventionDiscovery.AddFromAssemblyOf<EnumConvention>();
    })
    ./* other configuration */
```
- avec "int mode" comme valeur par défaut. Qui persiste énumérations comme des chaînes de caractères?!
- Pourrait être un héritage de la base de données avec les valeurs de chaîne déjà là
- +1 hainesy. @ Andrew Bullock: la réponse à votre question: toute personne qui traite avec le monde réel des bases de données.
- Est-il IProperty interface FN?
InformationsquelleAutor Garry Shutler

N'oubliez pas d'accepter les valeurs null énumérations (comme ExampleEnum? ExampleProperty)! Ils doivent être vérifiés séparément. C'est la façon dont c'est fait avec le nouveau FN style de configuration:

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

+1 Pour cet ajout! La première version ne fonctionne pas pour la nullable les énumérations (ils restent comme des chaînes de caractères).
Le type de colonne dans la base de données est int? Et quand le type accepte les Drapeaux? Comme: MyEnum.Active | MyEnum.Paused
Pour les drapeaux vérifier ici: stackoverflow.com/questions/2805661/...

InformationsquelleAutor SztupY

25

c'est de cette façon que j'ai mappé un enum propriété avec une valeur int:
```
Map(x => x.Status).CustomType(typeof(Int32));
```
fonctionne pour moi!
- Merci de fournir la réponse la plus simple
- Mon seul scrupule avec ceci est que vous ne devez pas oublier de l'appliquer à tous les enum. C'est ce que les conventions ont été créés pour.
- Cela fonctionne pour la lecture, mais a échoué quand j'ai essayé un des critères de la requête. La configuration d'une convention (voir la réponse à cette question) n'a fonctionné dans tous les cas, j'ai essayé de bien.
- Super réponse!..
- Eh bien, je pensais que c'était super, mais cela risque de causer des problèmes: voir ce post. nhforge.org/blogs/nhibernate/archive/2008/10/20/...
- Il semble que ce problème a été corrigé et est maintenant recommandé par James Gregory, de l'hôtel NH de l'équipe: mail-archive.com/[email protected]/...
InformationsquelleAutor Felipe

Pour ceux qui utilisent Couramment NHibernate avec mappant automatiquement (et potentiellement un conteneur IoC):

La IUserTypeConvention est que @Julien's réponse ci-dessus: 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 fluidité de la NHibernate mappant automatiquement la configuration pourrait être configuré comme ceci:

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

*Puis le CreateSessionFactory peut être utilisé dans un Cio, tels que le Château de Windsor (à l'aide d'un PersistenceFacility et de l'installateur) facilement. *

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

InformationsquelleAutor lko

0

Vous pouvez créer une NHibernate IUserType, et de spécifier à l'aide de CustomTypeIs<T>() sur la carte de propriété.

InformationsquelleAutor James Gregory

Vous devez garder les valeurs de type int /tinyint dans votre base de données de la Table. Pour la cartographie de votre enum vous devez spécifier le mappage correctement. Veuillez voir ci-dessous la cartographie et de l'enum de l'échantillon,

De La Cartographie Des

public class TransactionMap : ClassMap Transaction 
{ 
public TransactionMap() 
{ 
//D'autres mappages 
..... 
//Pour la cartographie enum 
Carte(x => x.Statut, "Le Statut").CustomType(); 

Tableau("Transaction"); 
} 
}

Enum

public enum TransactionStatus 
{ 
En attente = 1, 
Traitées = 2, 
RolledBack = 3, 
Bloqué = 4, 
Remboursé = 5, 
AlreadyProcessed = 6, 
}

InformationsquelleAutor Arkadas Kilic

Vous devez vous connecter pour publier un commentaire.