वर्ग गुणों के साथ मैन्युअल रूप से स्तंभ नाम

Question

मैं डैपर माइक्रो ORM में नया हूं। अब तक मैं साधारण ओआरएम संबंधित सामान के लिए इसका उपयोग करने में सक्षम हूं, लेकिन मैं क्लास के गुणों के साथ डेटाबेस कॉलम नामों को मैप करने में सक्षम नहीं हूं।

उदाहरण के लिए, मेरे पास निम्नलिखित डेटाबेस तालिका है:

Table Name: Person
person_id  int
first_name varchar(50)
last_name  varchar(50)

और मेरे पास व्यक्ति नामक एक वर्ग है:

public class Person 
{
    public int PersonId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

कृपया ध्यान दें कि तालिका में मेरा कॉलम नाम उस वर्ग के संपत्ति के नाम से भिन्न है जिससे मैं उस डेटा को मैप करने का प्रयास कर रहा हूं जो मुझे क्वेरी परिणाम से मिला था।

var sql = @"select top 1 PersonId,FirstName,LastName from Person";
using (var conn = ConnectionFactory.GetConnection())
{
    var person = conn.Query<Person>(sql).ToList();
    return person;
}

उपरोक्त कोड काम नहीं करेगा क्योंकि स्तंभ के नाम ऑब्जेक्ट (व्यक्ति) के गुणों से मेल नहीं खाते हैं। इस परिदृश्य में, क्या ऐसा कुछ है जिसे मैं डैपर में मैन्युअल रूप से मैप करने के लिए कर सकता हूं (जैसे person_id => PersonId) ऑब्जेक्ट के गुणों के साथ कॉलम के नाम?

Comments

संभव डापर की

— डेविड मैकलेनै

Answer 1

यह ठीक काम करता है:

var sql = @"select top 1 person_id PersonId, first_name FirstName, last_name LastName from Person";
using (var conn = ConnectionFactory.GetConnection())
{
    var person = conn.Query<Person>(sql).ToList();
    return person;
}

डैपर की कोई सुविधा नहीं है जो आपको एक कॉलम विशेषता को निर्दिष्ट करने की अनुमति देता है , मैं इसके लिए समर्थन जोड़ने के खिलाफ नहीं हूं, बशर्ते कि हम निर्भरता में न खींचे।

Comments

@ सॅम सैफ्रन कोई भी तरीका है जिससे मैं टेबल उर्फ ​​निर्दिष्ट कर सकता हूं। मेरे पास एक वर्ग है जिसका नाम देश है लेकिन db में आर्कटिक नामकरण परंपराओं के कारण तालिका का नाम बहुत जटिल है।

— TheVillageIdiot

संग्रहीत कार्यविधि परिणामों की मैपिंग के लिए कॉलम एट्रीब्यू काम में आएगा।

— रॉनी ओवरबी

स्तंभ विशेषताएँ आपके डोमेन और टूल कार्यान्वयन विवरणों के बीच अधिक आसानी से तंग भौतिक और / या शब्दार्थ युग्मन की सुविधा के लिए भी उपयोगी होंगी जो आप अपनी संस्थाओं को भौतिक बनाने के लिए उपयोग कर रहे हैं। इसलिए, इसके लिए समर्थन न जोड़ें !!!! :)

— डेरेक ग्रीर

जब टैब्लेट्रिब्यूट नहीं होता है तो मुझे कॉलम क्यों नहीं मिलता है। यह उदाहरण आवेषण, अद्यतन और SPs के साथ कैसे काम करेगा? मैं स्तंभकार, उसके मृत सरल को देखना चाहूंगा और अन्य समाधानों से जीवन को बहुत आसान बना दूंगा जो कि अब कुछ ऐसे ही लागू होते हैं जैसे कि अब अशुद्ध लिनाक-वर्ग।

— Vman

Answer 2

Dapper अब प्रॉपर्टी मैपर्स को कस्टम कॉलम सपोर्ट करता है। यह ITypeMap इंटरफ़ेस के माध्यम से ऐसा करता है। Dapper द्वारा एक CustomPropertyTypeMap वर्ग प्रदान किया जाता है जो इस कार्य को कर सकता है। उदाहरण के लिए:

Dapper.SqlMapper.SetTypeMap(
    typeof(TModel),
    new CustomPropertyTypeMap(
        typeof(TModel),
        (type, columnName) =>
            type.GetProperties().FirstOrDefault(prop =>
                prop.GetCustomAttributes(false)
                    .OfType<ColumnAttribute>()
                    .Any(attr => attr.Name == columnName))));

और मॉडल:

public class TModel {
    [Column(Name="my_property")]
    public int MyProperty { get; set; }
}

यह नोट करना महत्वपूर्ण है कि CustomPropertyTypeMap के कार्यान्वयन के लिए आवश्यक है कि विशेषता मौजूद हो और स्तंभ नामों में से एक से मेल खाए या संपत्ति मैप नहीं की जाएगी। DefaultTypeMap वर्ग मानक सुविधा प्रदान करता है और इस व्यवहार को बदलने के लिए उपयोग किया जा सकता:

public class FallbackTypeMapper : SqlMapper.ITypeMap
{
    private readonly IEnumerable<SqlMapper.ITypeMap> _mappers;

    public FallbackTypeMapper(IEnumerable<SqlMapper.ITypeMap> mappers)
    {
        _mappers = mappers;
    }

    public SqlMapper.IMemberMap GetMember(string columnName)
    {
        foreach (var mapper in _mappers)
        {
            try
            {
                var result = mapper.GetMember(columnName);
                if (result != null)
                {
                    return result;
                }
            }
            catch (NotImplementedException nix)
            {
            // the CustomPropertyTypeMap only supports a no-args
            // constructor and throws a not implemented exception.
            // to work around that, catch and ignore.
            }
        }
        return null;
    }
    // implement other interface methods similarly

    // required sometime after version 1.13 of dapper
    public ConstructorInfo FindExplicitConstructor()
    {
        return _mappers
            .Select(mapper => mapper.FindExplicitConstructor())
            .FirstOrDefault(result => result != null);
    }
}

और उस जगह के साथ, एक कस्टम प्रकार का मैपर बनाना आसान हो जाता है जो स्वचालित रूप से विशेषताओं का उपयोग करेगा यदि वे मौजूद हैं, लेकिन अन्यथा मानक व्यवहार पर वापस आ जाएंगे:

public class ColumnAttributeTypeMapper<T> : FallbackTypeMapper
{
    public ColumnAttributeTypeMapper()
        : base(new SqlMapper.ITypeMap[]
            {
                new CustomPropertyTypeMap(
                   typeof(T),
                   (type, columnName) =>
                       type.GetProperties().FirstOrDefault(prop =>
                           prop.GetCustomAttributes(false)
                               .OfType<ColumnAttribute>()
                               .Any(attr => attr.Name == columnName)
                           )
                   ),
                new DefaultTypeMap(typeof(T))
            })
    {
    }
}

इसका मतलब है कि अब हम आसानी से उन प्रकारों का समर्थन कर सकते हैं जिनके लिए विशेषताओं का उपयोग करके मानचित्र की आवश्यकता होती है:

Dapper.SqlMapper.SetTypeMap(
    typeof(MyModel),
    new ColumnAttributeTypeMapper<MyModel>());

यहां पूर्ण स्रोत कोड के लिए एक Gist है ।

Comments

मैं इसी मुद्दे के साथ संघर्ष कर रहा हूं ... और ऐसा लगता है कि मुझे जिस मार्ग पर जाना चाहिए ... मैं काफी उलझन में हूं कि इस कोड को "Dapper.SqlMapper.SetTypeMap (टाइपऑफ (MyModel)) कहा जाएगा। नया कॉलमअभियानटाइपपेपर <MyModel> ()) ;; stackoverflow.com/questions/14814972/…

— रोहन ब्यूनर

आप कोई भी प्रश्न करने से पहले एक बार कॉल करना चाहेंगे। आप इसे एक स्थिर निर्माता में कर सकते हैं, उदाहरण के लिए, क्योंकि इसे केवल एक बार बुलाया जाना चाहिए।

— कालेब पेडरसन

इसे आधिकारिक उत्तर बनाने की अनुशंसा करें - डॅपर की यह सुविधा अत्यंत उपयोगी है।

— किलथ्रश

@ ऑलिवर ( stackoverflow.com/a/34856158/364568 ) द्वारा पोस्ट किए गए मैपिंग समाधान काम करता है और कम कोड की आवश्यकता होती है।

— रीगा

मैं प्यार करता हूँ कि कैसे शब्द "आसानी से" इतनी आसानी से चारों ओर फेंक दिया जाता है: पी

— जोनाथन बी।

Answer 3

कुछ समय के लिए, निम्नलिखित कार्य करना चाहिए:

Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;

Comments

हालांकि यह वास्तव में " क्लास गुणों के साथ मैन्युअल रूप से मैप कॉलम के नाम " के सवाल का जवाब नहीं है , मेरे लिए यह मैन्युअल रूप से मैप करने की तुलना में बहुत अच्छा है (दुर्भाग्य से पोस्टग्रेक्यूएल में कॉलम नामों में अंडरस्कोर का उपयोग करना बेहतर है)। कृपया अगले संस्करणों में MatchNamesWithUnderscores विकल्प को न निकालें! धन्यवाद!!!

— 20

@victorvartan MatchNamesWithUnderscoresविकल्प को हटाने की कोई योजना नहीं है। सबसे अच्छा है , अगर हमने कॉन्फ़िगरेशन API को रिफ्लेक्ट किया है, तो मैं MatchNamesWithUnderscoresसदस्य को जगह में छोड़ दूंगा (जो अभी भी काम करता है, आदर्श रूप से) और [Obsolete]नए API से लोगों को इंगित करने के लिए एक मार्कर जोड़ें ।

— मार्क Gravell

@MarcGravel शब्द "कुछ समय के लिए" आपके उत्तर की शुरुआत में मुझे चिंता हुई कि आप इसे भविष्य के संस्करण में हटा सकते हैं, स्पष्ट करने के लिए धन्यवाद! और Dapper के लिए एक बड़ा धन्यवाद, एक अद्भुत माइक्रो ORM जो मैंने अभी ASP.NET Core पर Npgsql के साथ एक छोटे प्रोजेक्ट के लिए उपयोग करना शुरू किया था!

— विजोरवर्तन

यह आसानी से सबसे अच्छा जवाब है। मुझे काम के आसपास ढेर और ढेर मिले हैं, लेकिन आखिरकार इस पर ठोकर खाई। आसानी से सबसे अच्छा लेकिन कम से कम विज्ञापित जवाब।

— TeaMonkeyFruit 7

Answer 4

यहां एक सरल समाधान है, जिसमें आपको अपने POCOs से बुनियादी ढांचा कोड रखने की अनुमति देने वाले विशेषताओं की आवश्यकता नहीं है।

यह मैपिंग से निपटने के लिए एक वर्ग है। यदि आप सभी स्तंभों को मैप करते हैं, तो एक शब्दकोश काम करेगा, लेकिन यह वर्ग आपको केवल मतभेदों को निर्दिष्ट करने की अनुमति देता है। इसके अलावा, इसमें रिवर्स मैप्स शामिल हैं ताकि आप फ़ील्ड से कॉलम और कॉलम फ़ील्ड से प्राप्त कर सकें, जो कि एसक्यूएल स्टेटमेंट जेनरेट करने जैसी चीजों को करते समय उपयोगी हो सकता है।

public class ColumnMap
{
    private readonly Dictionary<string, string> forward = new Dictionary<string, string>();
    private readonly Dictionary<string, string> reverse = new Dictionary<string, string>();

    public void Add(string t1, string t2)
    {
        forward.Add(t1, t2);
        reverse.Add(t2, t1);
    }

    public string this[string index]
    {
        get
        {
            // Check for a custom column map.
            if (forward.ContainsKey(index))
                return forward[index];
            if (reverse.ContainsKey(index))
                return reverse[index];

            // If no custom mapping exists, return the value passed in.
            return index;
        }
    }
}

ColumnMap ऑब्जेक्ट सेट करें और मैपिंग का उपयोग करने के लिए Dapper को बताएं।

var columnMap = new ColumnMap();
columnMap.Add("Field1", "Column1");
columnMap.Add("Field2", "Column2");
columnMap.Add("Field3", "Column3");

SqlMapper.SetTypeMap(typeof (MyClass), new CustomPropertyTypeMap(typeof (MyClass), (type, columnName) => type.GetProperty(columnMap[columnName])));

Comments

यह एक अच्छा समाधान है जब आप मूल रूप से अपने POCO में गुणों का एक बेमेल है जो आपके डेटाबेस से वापस आ रहा है, उदाहरण के लिए, एक संग्रहीत प्रक्रिया।

— क्रश

मैं एक विशेषता का उपयोग करने वाली संक्षिप्तता को पसंद करता हूं, लेकिन वैचारिक रूप से यह विधि क्लीनर है - यह डेटाबेस विवरणों के लिए आपके POCO को युगल नहीं करता है।

— ब्रूनो ब्रांट

अगर मैं डैपर को सही ढंग से समझता हूं, तो इसके पास एक विशिष्ट इंसर्ट () विधि नहीं है, बस एक एक्सक्यूट () ... क्या यह मैपिंग अप्रोच के लिए काम करेगा? या अपडेट? धन्यवाद

— UuDdLrLrSs

Answer 5

मैं गतिशील और LINQ का उपयोग करते हुए निम्नलिखित करता हूं:

    var sql = @"select top 1 person_id, first_name, last_name from Person";
    using (var conn = ConnectionFactory.GetConnection())
    {
        List<Person> person = conn.Query<dynamic>(sql)
                                  .Select(item => new Person()
                                  {
                                      PersonId = item.person_id,
                                      FirstName = item.first_name,
                                      LastName = item.last_name
                                  }
                                  .ToList();

        return person;
    }

Answer 6

इसे प्राप्त करने का एक आसान तरीका यह है कि अपनी क्वेरी में केवल कॉलम पर उपनामों का उपयोग करें। यदि आपका डेटाबेस कॉलम है PERSON_IDऔर आपकी ऑब्जेक्ट की संभावना यह है कि IDआप बस select PERSON_ID as Id ...अपनी क्वेरी में कर सकते हैं और Dapper इसे अपेक्षित रूप से उठाएगा ।

Answer 7

डापर टेस्ट से लिया गया जो वर्तमान में डेपर 1.42 पर है।

// custom mapping
var map = new CustomPropertyTypeMap(typeof(TypeWithMapping), 
                                    (type, columnName) => type.GetProperties().FirstOrDefault(prop => GetDescriptionFromAttribute(prop) == columnName));
Dapper.SqlMapper.SetTypeMap(typeof(TypeWithMapping), map);

हेल्पर क्लास विवरण वर्णन का नाम पाने के लिए (मैंने व्यक्तिगत रूप से @kalebs उदाहरण जैसे कॉलम का उपयोग किया है)

static string GetDescriptionFromAttribute(MemberInfo member)
{
   if (member == null) return null;

   var attrib = (DescriptionAttribute)Attribute.GetCustomAttribute(member, typeof(DescriptionAttribute), false);
   return attrib == null ? null : attrib.Description;
}

कक्षा

public class TypeWithMapping
{
   [Description("B")]
   public string A { get; set; }

   [Description("A")]
   public string B { get; set; }
}

Comments

आदेश जहां का कोई विवरण नहीं परिभाषित किया गया है यह गुणों के लिए भी काम करने के लिए, मैं की वापसी बदल GetDescriptionFromAttributeकरने के लिए return (attrib?.Description ?? member.Name).ToLower();और कहा कि .ToLower()करने के लिए columnNameनक्शे में यह केस संवेदी नहीं होना चाहिए।

— सैम व्हाइट

Answer 8

मैपिंग के साथ मेसिंग वास्तविक ORM भूमि में चलती है। इसके साथ लड़ने और डापर को अपने वास्तविक सरल (तेज़) रूप में रखने के बजाय, बस अपनी एसक्यूएल को थोड़ा संशोधित करें:

var sql = @"select top 1 person_id as PersonId,FirstName,LastName from Person";

Answer 9

अपने डेटाबेस से कनेक्शन खोलने से पहले, अपने प्रत्येक पोको वर्ग के लिए कोड के इस टुकड़े को निष्पादित करें:

// Section
SqlMapper.SetTypeMap(typeof(Section), new CustomPropertyTypeMap(
    typeof(Section), (type, columnName) => type.GetProperties().FirstOrDefault(prop =>
    prop.GetCustomAttributes(false).OfType<ColumnAttribute>().Any(attr => attr.Name == columnName))));

फिर इस तरह अपने poco वर्गों में डेटा एनोटेशन जोड़ें:

public class Section
{
    [Column("db_column_name1")] // Side note: if you create aliases, then they would match this.
    public int Id { get; set; }
    [Column("db_column_name2")]
    public string Title { get; set; }
}

उसके बाद, आप सभी सेट हैं। बस एक क्वेरी कॉल करें, जैसे कुछ:

using (var sqlConnection = new SqlConnection("your_connection_string"))
{
    var sqlStatement = "SELECT " +
                "db_column_name1, " +
                "db_column_name2 " +
                "FROM your_table";

    return sqlConnection.Query<Section>(sqlStatement).AsList();
}

Comments

इसमें कॉलम गुण होने के लिए सभी गुणों की आवश्यकता होती है। क्या मैपर में प्रॉपर्टी के साथ मैप करने का कोई तरीका उपलब्ध नहीं है?

— sandeep.gosavi

Answer 10

यदि आप .NET 4.5.1 या उच्चतर चेकआउट Dapper.FluentColumnMapping का उपयोग कर रहे हैं , तो LINQ शैली को मैप करने के लिए। यह आपको अपने मॉडल से db मैपिंग को पूरी तरह से अलग करने देता है (एनोटेशन की कोई आवश्यकता नहीं)

Comments

मैं Dapper.FluentColumnMapping का लेखक हूं। मॉडल से मैपिंग को अलग करना प्राथमिक डिजाइन लक्ष्यों में से एक था। मैं चिंताओं के स्वच्छ पृथक्करण के लिए डेटाबेस-विशिष्ट ठोस कार्यान्वयन से कोर डेटा एक्सेस (यानी रिपॉजिटरी इंटरफेस, मॉडल ऑब्जेक्ट्स आदि ...) को अलग करना चाहता था। उल्लेख के लिए धन्यवाद और मुझे खुशी है कि आपने इसे उपयोगी पाया! :-)

— अलेक्जेंडर

github.com/henkmollema/Dapper-FluentMap समान है। लेकिन अब आपको तीसरे पक्ष के पैकेज की आवश्यकता नहीं है। Dapper ने Dapper.SqlMapper को जोड़ा। अधिक जानकारी के लिए मेरा उत्तर देखें यदि आप रुचि रखते हैं।

— तडज

Answer 11

यह अन्य उत्तरों से दूर है। यह सिर्फ एक विचार है जिसे मैंने क्वेरी स्ट्रिंग्स के प्रबंधन के लिए किया था।

Person.cs

public class Person 
{
    public int PersonId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public static string Select() 
    {
        return $"select top 1 person_id {nameof(PersonId)}, first_name {nameof(FirstName)}, last_name {nameof(LastName)}from Person";
    }
}

एपीआई विधि

using (var conn = ConnectionFactory.GetConnection())
{
    var person = conn.Query<Person>(Person.Select()).ToList();
    return person;
}

Answer 12

आप सभी के लिए जो डेपर १.१२ का उपयोग करते हैं, यहाँ आपको यह करने की आवश्यकता है:

एक नया कॉलम विशेषता वर्ग जोड़ें:

  [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property]

  public class ColumnAttribute : Attribute
  {

    public string Name { get; set; }

    public ColumnAttribute(string name)
    {
      this.Name = name;
    }
  }

इस पंक्ति को खोजें:

map = new DefaultTypeMap(type);

और इसे टिप्पणी करें।

इसके बजाय इसे लिखें:

        map = new CustomPropertyTypeMap(type, (t, columnName) =>
        {
          PropertyInfo pi = t.GetProperties().FirstOrDefault(prop =>
                            prop.GetCustomAttributes(false)
                                .OfType<ColumnAttribute>()
                                .Any(attr => attr.Name == columnName));

          return pi != null ? pi : t.GetProperties().FirstOrDefault(prop => prop.Name == columnName);
        });

Comments

मुझे यकीन नहीं है कि मैं समझता हूं - क्या आप अनुशंसा कर रहे हैं कि उपयोगकर्ता कॉलम द्वारा संभव मैपिंग बनाने के लिए डैपर को बदल सकते हैं? यदि ऐसा है, तो डापर में परिवर्तन किए बिना मेरे द्वारा ऊपर पोस्ट किए गए कोड का उपयोग करना संभव है।

— कालेब पेडरसन

लेकिन फिर आपको अपने प्रत्येक प्रकार के प्रत्येक के लिए मैपिंग फ़ंक्शन को कॉल करना होगा ?? मुझे जेनेरिक समाधान में दिलचस्पी है ताकि मेरे सभी प्रकार प्रत्येक प्रकार के लिए मैपिंग को कॉल किए बिना विशेषता का उपयोग कर सकें।

— उरई अब्रामसन

मैं देखना चाहूंगा कि DefaultTypeMap एक रणनीति पैटर्न का उपयोग करके कार्यान्वित किया जाता है ताकि इसे @UriAbramsh उल्लेखों के कारण बदला जा सके। कोड देखें। http://www.p/dapper-dot-net/issues/detail

— रिचर्ड कोलेट

Answer 13

कालेब पेडरसन के समाधान ने मेरे लिए काम किया। मैंने एक कस्टम विशेषता (एक ही डोमेन ऑब्जेक्ट पर दो अलग-अलग मैपिंग के लिए आवश्यकता होती है) और अद्यतन किए गए गुणों की अनुमति देने के लिए ColumnAttributeTypeMapper को अपडेट किया और उन मामलों में निजी बसने की अनुमति देने के लिए अद्यतन किया जहां फ़ील्ड व्युत्पन्न करने की आवश्यकता होती है और प्रकार भिन्न होते हैं।

public class ColumnAttributeTypeMapper<T,A> : FallbackTypeMapper where A : ColumnAttribute
{
    public ColumnAttributeTypeMapper()
        : base(new SqlMapper.ITypeMap[]
            {
                new CustomPropertyTypeMap(
                   typeof(T),
                   (type, columnName) =>
                       type.GetProperties( BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).FirstOrDefault(prop =>
                           prop.GetCustomAttributes(true)
                               .OfType<A>()
                               .Any(attr => attr.Name == columnName)
                           )
                   ),
                new DefaultTypeMap(typeof(T))
            })
    {
        //
    }
}

Answer 14

मुझे पता है कि यह एक अपेक्षाकृत पुराना धागा है, लेकिन मुझे लगा कि मैं वहीं फेंकूंगा जो मैंने किया था।

मैं विश्व स्तर पर काम करने के लिए विशेषता-मानचित्रण चाहता था। या तो आप गुण नाम (उर्फ डिफ़ॉल्ट) से मेल खाते हैं या आप वर्ग गुण पर एक स्तंभ विशेषता से मेल खाते हैं। मैं यह भी नहीं चाहता था कि मैं जिस हर एक वर्ग के लिए मैपिंग कर रहा था, उसके लिए इसे स्थापित किया जाए। जैसे, मैंने एक DapperStart क्लास बनाई, जिसे मैंने ऐप स्टार्ट पर शुरू किया:

public static class DapperStart
{
    public static void Bootstrap()
    {
        Dapper.SqlMapper.TypeMapProvider = type =>
        {
            return new CustomPropertyTypeMap(typeof(CreateChatRequestResponse),
                (t, columnName) => t.GetProperties().FirstOrDefault(prop =>
                    {
                        return prop.Name == columnName || prop.GetCustomAttributes(false).OfType<ColumnAttribute>()
                                   .Any(attr => attr.Name == columnName);
                    }
                ));
        };
    }
}

बहुत साधारण। निश्चित नहीं कि मैं अभी तक किन मुद्दों पर चलूंगा क्योंकि मैंने इसे लिखा था, लेकिन यह काम करता है।

Comments

CreateChatRequestResponse कैसा दिखता है? इसके अलावा, आप इसे स्टार्टअप में कैसे शामिल कर रहे हैं?

— ग्लेन एफ।

@GlenF। मुद्दा यह है कि यह कोई फर्क नहीं पड़ता कि CreateChatRequestResponse कैसा दिखता है। यह किसी भी POCO हो सकता है यह आपके स्टार्टअप में लागू हो जाता है। आप इसे बस अपने StartUp.cs या अपने Global.asax में अपने ऐप पर शुरू कर सकते हैं।

— मैट एम

शायद मैं पूरी तरह से गलत हूं, लेकिन जब तक CreateChatRequestResponseकि इसे Tसभी एंटिटी ऑब्जेक्ट्स के माध्यम से पुनरावृत्त नहीं किया जाएगा। अगर मैं गलत हूं कृपया मुझे सही।

— Fwd079

Answer 15

समस्या को हल करने के लिए Kaleb हल करने की कोशिश कर रहा है, बस गुण नाम स्वीकार करने के लिए अगर स्तंभ विशेषता मौजूद नहीं है:

Dapper.SqlMapper.SetTypeMap(
    typeof(T),
    new Dapper.CustomPropertyTypeMap(
        typeof(T),
        (type, columnName) =>
            type.GetProperties().FirstOrDefault(prop =>
                prop.GetCustomAttributes(false)
                    .OfType<ColumnAttribute>()
                    .Any(attr => attr.Name == columnName) || prop.Name == columnName)));