Another question regarding modifying the Insert routine to handle Sql tables with non-identity ID fields

[tmsmith]

Another question regarding modifying the Insert routine to handle Sql tables with non-identity ID fields

[tmsmith]

The CanMap is called for each property. The propertyInfo is the property that is currently being mapped.

If you want to define the mapper for every class you can set the DefaultMapper to the new Mapper

DapperExtensions.DefaultMapper = typeof(MyClassMapper<>);

If you want to setup this for a single class you can create a mapper for that class and DE will pick it up.

public class MyEntityMapper : MyClassMapper<MyEntity>
{
}

Or you can check T to determine if you want to do this special mapping.

[rbsorensen]

Thanks,

I got it working with the following changes:

1. A new class named NoIdentityClassMapper defined as follows:

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text;

namespace DapperExtensions.Mapper
{
public class NoIdentityClassMapper : AutoClassMapper where T : class
{
protected override void AutoMap()
{
Type type = typeof(T);
bool keyFound = Properties.Any(p => p.KeyType != KeyType.NotAKey);
foreach (var propertyInfo in type.GetProperties())
{
if (Properties.Any(p => p.Name.Equals(propertyInfo.Name, StringComparison.InvariantCultureIgnoreCase)))
{
continue;
}

            PropertyMap map = Map(propertyInfo);

            if (!keyFound && map.PropertyInfo.Name.EndsWith("id", true, CultureInfo.InvariantCulture))
            {
                map.Key(KeyType.Assigned);
                keyFound = true;
            }
        }
    }
}

}

1. Changes to DapperExtensions.cs as follows:

   public static void Insert<T>(this IDbConnection connection, IEnumerable<T> entities, bool noIdentityMapping, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
   {
       Instance.Insert<T>(connection, entities, noIdentityMapping, transaction, commandTimeout);
   }
   
   
   public static dynamic Insert<T>(this IDbConnection connection, T entity, bool noIdentityMapping, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
   {
       return Instance.Insert<T>(connection, entity, noIdentityMapping, transaction, commandTimeout);
   }
   
   
   public interface IDapperExtensionsImpl
   {
   

   ...
   void Insert(IDbConnection connection, IEnumerable entities, bool noIdentityMapping, IDbTransaction transaction, int? commandTimeout) where T : class;
   dynamic Insert(IDbConnection connection, T entity, bool noIdentityMapping, IDbTransaction transaction, int? commandTimeout) where T : class;
   ...
   }

       public void Insert<T>(IDbConnection connection, IEnumerable<T> entities, bool noIdentityMapping, IDbTransaction transaction, int? commandTimeout) where T : class
       {
           if (noIdentityMapping)
               DefaultMapper = typeof(NoIdentityClassMapper<>);
           else
               DefaultMapper = typeof(AutoClassMapper<>);
           IClassMapper classMap = GetMap<T>();
   

   ...

       public dynamic Insert<T>(IDbConnection connection, T entity, bool noIdentityMapping, IDbTransaction transaction, int? commandTimeout) where T : class
       {
           if (noIdentityMapping)
               DefaultMapper = typeof(NoIdentityClassMapper<>);
           else
               DefaultMapper = typeof(AutoClassMapper<>);
           IClassMapper classMap = GetMap<T>(); 
   

   ...

You may want to add this to your released source