धाराप्रवाह NHibernate के साथ एक आंतरिक मान के रूप में आप एक एनम कैसे मैप करते हैं?

Question 1

सवाल यह सब वास्तव में कहते हैं, डिफ़ॉल्ट के रूप में यह नक्शे के लिए है, stringलेकिन मैं इसे एक के रूप में नक्शे की जरूरत है int।

मैं वर्तमान में PersistenceModelअपने सम्मेलनों को सेट करने के लिए उपयोग कर रहा हूं अगर इससे कोई फर्क पड़ता है। अग्रिम में धन्यवाद।

अपडेट पाया गया कि ट्रंक से कोड के नवीनतम संस्करण पर प्राप्त करने से मेरी परेशानी हल हो गई।

Question 2

इस सम्मेलन को परिभाषित करने का तरीका कभी-कभी बदल गया है, यह अब है:

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

Question 3

इसलिए, जैसा कि उल्लेख किया गया है, ट्रंक से धाराप्रवाह NHibernate का नवीनतम संस्करण प्राप्त करना मुझे वह स्थान मिला जहां मुझे होने की आवश्यकता थी। नवीनतम कोड के साथ एक एनम के लिए एक उदाहरण मैपिंग है:

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

कस्टम प्रकार इसे उपयोग करने के बजाय एनम के उदाहरण के रूप में नियंत्रित करने के लिए मजबूर करता है GenericEnumMapper<TEnum>।

मैं वास्तव में एक थैली को बनाए रखने में सक्षम होने के लिए एक पैच को प्रस्तुत करने पर विचार कर रहा हूं जो एक स्ट्रिंग को बनाए रखता है और एक जो एक इंट को बनाए रखता है जो ऐसा लगता है जैसे आपको एक सम्मेलन के रूप में सेट करने में सक्षम होना चाहिए।

यह मेरी हाल की गतिविधि पर पॉप अप हुआ है और इस आसान को बनाने के लिए धाराप्रवाह NHibernate के नए संस्करणों में चीजें बदल गई हैं।

सभी एनमों को पूर्णांकों के रूप में मैप करने के लिए आप अब एक कन्वेंशन बना सकते हैं जैसे:

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

तब केवल आपकी मैपिंग होनी चाहिए:

Map(quote => quote.Status);

आप अपने धाराप्रवाह NHibernate मानचित्रण की तरह सम्मेलन को जोड़ते हैं;

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

Question 4

Nullable enums (जैसे ExampleEnum? ExampleProperty) के बारे में मत भूलना ! उन्हें अलग से जांचने की आवश्यकता है। यह इस तरह से नए 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);
    }
}

Question 5

इस तरह से मैंने एक एनम प्रॉपर्टी को एक इंट वैल्यू के साथ मैप किया है:

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

मेरे लिये कार्य करता है!

Question 6

स्वचालित (और संभवतः एक आईओसी कंटेनर के साथ) धाराप्रवाह NHibernate का उपयोग करने वालों के लिए:

IUserTypeConventionके रूप में @ है जुलिएन ऊपर के जवाब: 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);
    }
}

धाराप्रवाह NHibernate स्वचालित विन्यास इस तरह से कॉन्फ़िगर किया जा सकता है:

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

* तब CreateSessionFactoryआईओसी में उपयोग किया जा सकता है जैसे कि कैसल विंडसर (एक PersistenceFacility और इंस्टॉलर का उपयोग करके) आसानी से। *

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

Question 7

आप एक NHibernate बना सकते हैं IUserType, और इसे CustomTypeIs<T>()संपत्ति के नक्शे पर उपयोग करके निर्दिष्ट कर सकते हैं।

Question 8

आपको अपनी DB तालिका में मानों को int / smallint के रूप में रखना चाहिए। अपने एनम की मैपिंग के लिए आपको सही तरीके से मैपिंग निर्दिष्ट करने की आवश्यकता है। कृपया नीचे मानचित्रण और एनम नमूना देखें,

मैपिंग क्लास

सार्वजनिक वर्ग का लेन-देन मानचित्र: कक्षा मानचित्र लेनदेन
{
    सार्वजनिक लेनदेन मानचित्र ()
    {
        // अन्य मैपिंग
        .....
        // एनम के लिए मैपिंग
        मानचित्र (x => x.Status, "Status")। CustomType ();

        तालिका ( "लेन-देन");
    }
}

enum

सार्वजनिक एनम ट्रांज़ैक्शनस्टैटस
{
   प्रतीक्षा = 1,
   संसाधित = 2,
   रोल्डबैक = 3,
   अवरुद्ध = 4,
   रिफंड किया गया = 5,
   पहले से ही तैयार = 6,
}