private ObjectsMapperBaseImpl BuildObjectsMapper(
string MapperTypeName,
Type from,
Type to,
IMappingConfigurator mappingConfigurator)
{
TypeBuilder typeBuilder = DynamicAssemblyManager.DefineMapperType(MapperTypeName);
CreateTargetInstanceBuilder.BuildCreateTargetInstanceMethod(to, typeBuilder);
var mappingBuilder = new MappingBuilder(
this,
from,
to,
typeBuilder,
mappingConfigurator
);
mappingBuilder.BuildCopyImplMethod();
ObjectsMapperBaseImpl result =
(ObjectsMapperBaseImpl)Activator.CreateInstance(typeBuilder.CreateType());
result.Initialize(this, from, to, mappingConfigurator, mappingBuilder.storedObjects.ToArray());
return(result);
}
//private ModelConverter()
//{
//}
/// <summary>
/// object转换
/// </summary>
/// <typeparam name="TIn"></typeparam>
/// <typeparam name="TOut"></typeparam>
/// <param name="inData"></param>
/// <returns></returns>
public static TOut ConvertObject <TIn, TOut>(TIn inData)
{
Type tin = typeof(TIn);
Type tout = typeof(TOut);
string typeKey = string.Concat(tin, "|", tout);
ObjectsMapperBaseImpl mapperBase = null;
ObjectsMapper <TIn, TOut> mapper = null;
if (_dictMapping.TryGetValue(typeKey, out mapperBase))
{
mapper = new ObjectsMapper <TIn, TOut>(mapperBase);
}
else
{
mapper = ObjectMapperManager.DefaultInstance.GetMapper <TIn, TOut>();
_dictMapping[typeKey] = mapper.MapperImpl;
}
return(mapper.Map(inData));
}
public static bool BuildUpdateCommand(
this DbCommand cmd,
object obj,
string tableName,
IEnumerable <string> idFieldNames,
IEnumerable <string> includeFields,
IEnumerable <string> excludeFields,
ObjectsChangeTracker changeTracker,
DbSettings dbSettings
)
{
if (idFieldNames == null)
{
idFieldNames = new string[0];
}
//idFieldNames = idFieldNames.Select(n => n.ToUpper()).ToArray(); //不Upper会怎样
if (changeTracker != null)
{
ObjectsChangeTracker.TrackingMember[] changedFields = changeTracker.GetChanges(obj);
if (changedFields != null)
{
includeFields = includeFields == null?changedFields.Select(c => c.name).Except(idFieldNames).ToArray()
: includeFields.Intersect(changedFields.Select(c => c.name)).Except(idFieldNames).ToArray();
}
}
if (includeFields != null)
{
includeFields = includeFields.Concat(idFieldNames);
}
IMappingConfigurator config = new AddDbCommandsMappingConfig(
dbSettings,
includeFields,
excludeFields,
"updateop_inc_" + includeFields.ToCSV("_") + "_exc_" + excludeFields.ToCSV("_")
);
ObjectsMapperBaseImpl mapper = ObjectMapperManager.DefaultInstance.GetMapperImpl(
obj.GetType(),
typeof(DbCommand),
config
);
string[] fields = mapper
.StroredObjects
.OfType <SrcReadOperation>()
.Select(m => m.Source.MemberInfo.Name)
.Where(f => !idFieldNames.Contains(f))
.Except(idFieldNames)
.ToArray(); //2014-4-29 cannot change id.
if (fields.Length == 0)
{
return(false);
}
var enableCol = new string[] { "TableName", "IdName" };
fields = fields.Where(c => !enableCol.Contains(c)).ToArray();
string cmdStr =
"UPDATE " +
tableName +
" SET " +
fields.Select(
f => dbSettings.GetEscapedName(f) + "=" + dbSettings.GetParamName(f)
)
.ToCSV(",") +
" WHERE " +
idFieldNames.Select(fn => dbSettings.GetEscapedName(fn) + "=" + dbSettings.GetParamName(fn))
.ToCSV(" AND ")
;
cmd.CommandText = cmdStr;
cmd.CommandType = CommandType.Text;
mapper.Map(obj, cmd, null);
return(true);
}
public ObjectsMapperDescr(ObjectsMapperBaseImpl mapper, MapperKey key, int id)
{
this.mapper = mapper;
this.key = key;
this.id = id;
}
public ObjectsMapper(ObjectsMapperBaseImpl mapperImpl)
{
MapperImpl = mapperImpl;
}
/// <summary>
/// Creates a new type based on T , marks each public property of T
/// with ProtoMember, DataMember attributes. Also marks the classes
/// as ProtoContract or DataContract attributes.
/// </summary>
private void CreateClonedTypeWithAttributes()
{
string typeName = TypeOfActualObject.AssemblyQualifiedName ?? TypeOfActualObject.Name;
_assemblyName = Convert.ToBase64String(Encoding.ASCII.GetBytes(typeName));
if (!TryAndLoadClonedTypeAssembly())
{
TypeBuilder typeBuilder = CreateTypeBuilder();
var findProps = from propertyInfo in TypeOfActualObject.GetProperties()
.Where(iPropInfo => SystemTypes.fclDlls.Contains(iPropInfo.PropertyType.Assembly.FullName) &&
iPropInfo.MemberType == MemberTypes.Property &&
iPropInfo.GetSetMethod() != null)
select propertyInfo;
List <PropertyInfo> props = findProps.ToList();
int protoMemberId = 1;
foreach (PropertyInfo info in props)
{
FieldBuilder fieldBuilder = typeBuilder.DefineField(string.Format("m_{0}", info.Name),
info.PropertyType,
FieldAttributes.Private);
string getterName = string.Concat("get_", info.Name);
string setterName = string.Concat("set_", info.Name);
PropertyBuilder propBuilder
= typeBuilder.DefineProperty(info.Name,
PropertyAttributes.HasDefault,
CallingConventions.Standard,
info.PropertyType,
null);
//Apply ProtoMember Attribute
Type[] ctorParams = new[] { typeof(Int32) };
ConstructorInfo protoMbrCtorInfo = typeof(ProtoMemberAttribute).GetConstructor(ctorParams);
CustomAttributeBuilder protoMbrAttbBuilder = new CustomAttributeBuilder(protoMbrCtorInfo, new object[] { protoMemberId++ });
propBuilder.SetCustomAttribute(protoMbrAttbBuilder);
//Apply Data Member Attribute
ConstructorInfo classCtorInfo = typeof(DataMemberAttribute).GetConstructor(Type.EmptyTypes);
CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder(classCtorInfo, new object[] { });
propBuilder.SetCustomAttribute(attributeBuilder);
MethodBuilder getPropMethdBldr = typeBuilder.DefineMethod(getterName, GetSetAttr, info.PropertyType, Type.EmptyTypes);
ILGenerator getterIL = getPropMethdBldr.GetILGenerator();
getterIL.Emit(OpCodes.Ldarg_0);
getterIL.Emit(OpCodes.Ldfld, fieldBuilder);
getterIL.Emit(OpCodes.Ret);
MethodBuilder setPropMethdBldr = typeBuilder.DefineMethod(setterName, GetSetAttr, null, new[] { info.PropertyType });
ILGenerator setterIL = setPropMethdBldr.GetILGenerator();
setterIL.Emit(OpCodes.Ldarg_0);
setterIL.Emit(OpCodes.Ldarg_1);
setterIL.Emit(OpCodes.Stfld, fieldBuilder);
setterIL.Emit(OpCodes.Ret);
propBuilder.SetGetMethod(getPropMethdBldr);
propBuilder.SetSetMethod(setPropMethdBldr);
}
typeBuilder.CreateType();
//save the assembly in a preconfigured dir..
//before we try to create it, we can load all assemblies from the directory
_assemblyBuilder.Save(_assemblyName + ".dll");
}
if (TryAndLoadClonedTypeAssembly())
{
_mappedType = _assembly.GetTypes()[0];
_objectsMapperFrom = ObjectMapperManager.DefaultInstance.GetMapperImpl(TypeOfActualObject, _mappedType,
DefaultMapConfig.Instance);
_objectsMapperTo = ObjectMapperManager.DefaultInstance.GetMapperImpl(_mappedType, TypeOfActualObject,
DefaultMapConfig.Instance);
}
}
