/// <summary> /// 更新数据 /// </summary> /// <typeparam name="valueType">数据类型</typeparam> /// <typeparam name="modelType">模型类型</typeparam> /// <param name="sqlTool">SQL操作工具</param> /// <param name="value">匹配成员值</param> /// <param name="memberMap">成员位图</param> /// <param name="query">查询信息</param> /// <returns></returns> internal override bool Update <valueType, modelType> (Sql.Table <valueType, modelType> sqlTool, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query) { if (query.MemberMap == null) { query.MemberMap = sqlTool.GetSelectMemberMap(memberMap); } CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null); if (sqlStream == null) { sqlStream = new CharStream(null, 0); } byte *buffer = null; try { sqlStream.Reset(buffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize); if (DataModel.Model <modelType> .Identity != null) { if (!query.NotQuery) { getByIdentity(sqlStream, sqlTool.TableName, value, query.MemberMap); query.Sql = sqlStream.ToString(); sqlStream.ByteSize = 0; } sqlStream.SimpleWriteNotNull(" update `"); sqlStream.SimpleWriteNotNull(sqlTool.TableName); sqlStream.SimpleWriteNotNull("` set "); DataModel.Model <modelType> .Updater.Update(sqlStream, memberMap, value, ConstantConverter.Default, sqlTool); sqlStream.SimpleWriteNotNull(" where "); sqlStream.SimpleWriteNotNull(DataModel.Model <modelType> .IdentitySqlName); sqlStream.Write('='); AutoCSer.Extension.Number.ToString(DataModel.Model <modelType> .GetIdentity(value), sqlStream); sqlStream.Write(';'); query.UpdateSql = sqlStream.ToString(); return(true); } if (DataModel.Model <modelType> .PrimaryKeys.Length != 0) { if (!query.NotQuery) { getByPrimaryKey(sqlStream, sqlTool.TableName, value, query.MemberMap); query.Sql = sqlStream.ToString(); sqlStream.ByteSize = 0; } sqlStream.WriteNotNull(" update `"); sqlStream.WriteNotNull(sqlTool.TableName); sqlStream.WriteNotNull("` set "); DataModel.Model <modelType> .Updater.Update(sqlStream, memberMap, value, ConstantConverter.Default, sqlTool); sqlStream.WriteNotNull(" where "); DataModel.Model <modelType> .PrimaryKeyWhere.Write(sqlStream, value, ConstantConverter.Default); sqlStream.Write(';'); query.UpdateSql = sqlStream.ToString(); return(true); } } finally { if (buffer != null) { AutoCSer.UnmanagedPool.Default.Push(buffer); } sqlStream.Dispose(); Interlocked.Exchange(ref this.sqlStream, sqlStream); } return(false); }
public static MemberMap <T, ushort> PartFilename <T>(this MemberMap <T, ushort> map, string partType) { return(map.TypeConverter(Utils.GetFileNameConverter(partType))); }
public static void Set(DbDataReader reader, valueType value, MemberMap memberMap) { #if NOJIT if (fields != null) { int index = 0; object[] sqlColumnParameters = null, castParameters = null; foreach (sqlModel.setField field in fields) { AutoCSer.code.cSharp.sqlModel.fieldInfo fieldInfo = field.Field; if (memberMap.IsMember(fieldInfo.MemberMapIndex)) { if (fieldInfo.DataReaderMethod == null) { if (sqlColumnParameters == null) { sqlColumnParameters = new object[] { reader, null, null } } ; sqlColumnParameters[1] = null; sqlColumnParameters[2] = index; field.SqlColumnMethod.Invoke(null, sqlColumnParameters); fieldInfo.Field.SetValue(value, sqlColumnParameters[1]); index = (int)sqlColumnParameters[2]; } else { object memberValue; if (fieldInfo.DataType == fieldInfo.NullableDataType && (fieldInfo.DataType.IsValueType || !fieldInfo.DataMember.IsNull)) { memberValue = reader[index++]; if (fieldInfo.ToModelCastMethod != null) { if (castParameters == null) { castParameters = new object[1]; } castParameters[0] = memberValue; memberValue = fieldInfo.ToModelCastMethod.Invoke(null, castParameters); } } else if (reader.IsDBNull(index)) { memberValue = null; ++index; } else { memberValue = reader[index++]; if (fieldInfo.ToModelCastMethod != null && fieldInfo.DataType == fieldInfo.NullableDataType) { if (castParameters == null) { castParameters = new object[1]; } castParameters[0] = memberValue; memberValue = fieldInfo.ToModelCastMethod.Invoke(null, castParameters); } } fieldInfo.Field.SetValue(value, memberValue); } } } } #else if (setter != null) { setter(reader, value, memberMap); } #endif }
/// <summary> /// 更新数据 /// </summary> /// <param name="cacheValue"></param> /// <param name="value">更新后的数据</param> /// <param name="oldValue">更新前的数据</param> /// <param name="memberMap"></param> protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap) { keyType key = getKey(value), oldKey = getKey(oldValue); if (!key.Equals(oldKey)) { onInserted(cacheValue, key); onDeleted(oldKey); } }
/// <summary> /// Creates a member expression for the given member on the record. /// This will recursively traverse the mapping to find the member /// and create a safe member accessor for each level as it goes. /// </summary> /// <param name="recordExpression">The current member expression.</param> /// <param name="mapping">The mapping to look for the member to map on.</param> /// <param name="memberMap">The member map to look for on the mapping.</param> /// <returns>An Expression to access the given member.</returns> public virtual Expression CreateGetMemberExpression(Expression recordExpression, ClassMap mapping, MemberMap memberMap) { if (mapping.MemberMaps.Any(mm => mm == memberMap)) { // The member is on this level. if (memberMap.Data.Member is PropertyInfo) { return(Expression.Property(recordExpression, (PropertyInfo)memberMap.Data.Member)); } if (memberMap.Data.Member is FieldInfo) { return(Expression.Field(recordExpression, (FieldInfo)memberMap.Data.Member)); } } // The member isn't on this level of the mapping. // We need to search down through the reference maps. foreach (var refMap in mapping.ReferenceMaps) { var wrapped = refMap.Data.Member.GetMemberExpression(recordExpression); var memberExpression = CreateGetMemberExpression(wrapped, refMap.Data.Mapping, memberMap); if (memberExpression == null) { continue; } if (refMap.Data.Member.MemberType().GetTypeInfo().IsValueType) { return(memberExpression); } var nullCheckExpression = Expression.Equal(wrapped, Expression.Constant(null)); var isValueType = memberMap.Data.Member.MemberType().GetTypeInfo().IsValueType; var isGenericType = isValueType && memberMap.Data.Member.MemberType().GetTypeInfo().IsGenericType; Type memberType; if (isValueType && !isGenericType && !writer.Configuration.UseNewObjectForNullReferenceMembers) { memberType = typeof(Nullable <>).MakeGenericType(memberMap.Data.Member.MemberType()); memberExpression = Expression.Convert(memberExpression, memberType); } else { memberType = memberMap.Data.Member.MemberType(); } var defaultValueExpression = isValueType && !isGenericType ? (Expression)Expression.New(memberType) : Expression.Constant(null, memberType); var conditionExpression = Expression.Condition(nullCheckExpression, defaultValueExpression, memberExpression); return(conditionExpression); } return(null); }
public FieldInfo[] GetFields(BindingFlags bindFlags) { return(MemberMap.GetFields(GetAllPropertyNames())); }
public static bool Verify(modelType value, MemberMap memberMap, Table sqlTool) { #if NOJIT if (fields != null) { object[] sqlColumnParameters = null, castParameters = null; foreach (sqlModel.verifyField field in fields) { AutoCSer.code.cSharp.sqlModel.fieldInfo fieldInfo = field.Field; if (memberMap.IsMember(fieldInfo.MemberMapIndex)) { object memberValue = fieldInfo.Field.GetValue(value); if (field.IsSqlVerify) { if (!fieldInfo.Field.FieldType.IsValueType && memberValue == null) { return(false); } if (!(bool)((AutoCSer.emit.sqlTable.ISqlVerify)memberValue).IsSqlVeify()) { return(false); } } else if (fieldInfo.IsSqlColumn) { if (sqlColumnParameters == null) { sqlColumnParameters = new object[] { null, sqlTool, null } } ; sqlColumnParameters[0] = memberValue; sqlColumnParameters[2] = fieldInfo.Field.Name; if (!(bool)field.SqlColumnMethod.Invoke(null, sqlColumnParameters)) { return(false); } } else if (fieldInfo.DataType == typeof(string)) { if (fieldInfo.ToSqlCastMethod != null) { if (castParameters == null) { castParameters = new object[1]; } castParameters[0] = memberValue; memberValue = fieldInfo.ToSqlCastMethod.Invoke(null, castParameters); } dataMember dataMember = fieldInfo.DataMember; if (!sqlTool.StringVerify(fieldInfo.Field.Name, (string)memberValue, dataMember.MaxStringLength, dataMember.IsAscii, dataMember.IsNull)) { return(false); } } else { if (fieldInfo.ToSqlCastMethod != null && !fieldInfo.IsUnknownJson) { if (castParameters == null) { castParameters = new object[1]; } castParameters[0] = memberValue; memberValue = fieldInfo.ToSqlCastMethod.Invoke(null, castParameters); } if (memberValue == null) { sqlTool.NullVerify(fieldInfo.Field.Name); return(false); } } } } } return(true); #else return(verifyer == null || verifyer(value, memberMap, sqlTool)); #endif }
/// <summary> /// 更新数据 /// </summary> /// <param name="cacheValue">缓存数据</param> /// <param name="value">更新后的数据</param> /// <param name="oldValue">更新前的数据</param> /// <param name="memberMap"></param> private void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap) { keyType key = getKey(value); if (cacheValue == null) { ListArray <valueType> values; if (queueCache.Remove(ref key, out values)) { foreach (valueType removeValue in values) { counter.Remove(removeValue); } } } else { keyType oldKey = getKey(oldValue); if (!key.Equals(oldKey)) { ListArray <valueType> values = queueCache.Get(ref key, null), oldValues = queueCache.Get(ref oldKey, null); if (values != null) { if (oldValues != null) { values.Add(cacheValue); if (!oldValues.Remove(cacheValue)) { counter.SqlTable.Log.Fatal(typeof(valueType).FullName + " 缓存同步错误", LogLevel.Fatal | LogLevel.AutoCSer); } } else { values.Add(counter.Add(cacheValue)); } } else if (oldValues != null) { if (oldValues.Remove(cacheValue)) { counter.Remove(cacheValue); } else { counter.SqlTable.Log.Fatal(typeof(valueType).FullName + " 缓存同步错误", LogLevel.Fatal | LogLevel.AutoCSer); } } } } }
/// <summary> /// 更新数据 /// </summary> /// <param name="cacheValue"></param> /// <param name="value">更新后的数据</param> /// <param name="oldValue">更新前的数据</param> /// <param name="memberMap"></param> protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap) { keyType key = getKey(value), oldKey = getKey(oldValue); int index = getIndex(value), oldIndex = getIndex(oldValue); if (key.Equals(oldKey)) { if (index != oldIndex) { targetType target = getValue(key); if (target == null) { cache.SqlTable.Log.Add(AutoCSer.Log.LogType.Debug | AutoCSer.Log.LogType.Info, typeof(valueType).FullName + " 没有找到缓存目标对象 " + key.ToString()); } else { LazyOrderArray <valueType>[] arrays = getMember(target); if (arrays != null) { LazyOrderArray <valueType> array = arrays[index]; if (array == null) { arrays[index] = array = new LazyOrderArray <valueType>(); } array.Insert(cacheValue); if ((array = arrays[oldIndex]) != null) { array.Delete(cacheValue); return; } } cache.SqlTable.Log.Add(AutoCSer.Log.LogType.Fatal, typeof(valueType).FullName + " 缓存同步错误"); } } } else { onInserted(cacheValue, key, index); onDeleted(cacheValue, oldKey, getIndex(oldValue)); } }
public static void Insert(CharStream sqlStream, MemberMap memberMap, modelType value, ConstantConverter converter, Table table) { #if NOJIT if (fields != null) { object[] sqlColumnParameters = null, castParameters = null, parameters = null; byte isNext = 0; foreach (InsertField field in fields) { if (memberMap.IsMember(field.Field.MemberMapIndex)) { if (isNext == 0) { isNext = 1; } else { sqlStream.Write(','); } Field fieldInfo = field.Field; if (fieldInfo.IsSqlColumn) { if (sqlColumnParameters == null) { sqlColumnParameters = new object[] { sqlStream, null, converter } } ; sqlColumnParameters[1] = fieldInfo.FieldInfo.GetValue(value); field.SqlColumnMethod.Invoke(null, sqlColumnParameters); } else if (fieldInfo.NowTimeField == null) { object memberValue = fieldInfo.FieldInfo.GetValue(value); if (fieldInfo.ToSqlCastMethod != null) { if (castParameters == null) { castParameters = new object[1]; } castParameters[0] = memberValue; memberValue = fieldInfo.ToSqlCastMethod.Invoke(null, castParameters); } if (parameters == null) { parameters = new object[] { sqlStream, null } } ; parameters[1] = memberValue; fieldInfo.ToSqlMethod.Invoke(converter, parameters); } else { if (parameters == null) { parameters = new object[] { sqlStream, null } } ; parameters[1] = fieldInfo.NowTimeField.GetValue(null); fieldInfo.ToSqlMethod.Invoke(converter, parameters); } } } } #else if (inserter != null) { inserter(sqlStream, memberMap, value, converter, table); } #endif }
public EntityMember GetMemberFromColumn(ColumnSchema column) { return((MemberMap.ContainsKey(column)) ? MemberMap[column] : null); }
/// <summary> /// 获取添加数据 SQL 语句 /// </summary> /// <typeparam name="valueType">数据类型</typeparam> /// <typeparam name="modelType">模型类型</typeparam> /// <param name="sqlTool">SQL操作工具</param> /// <param name="value">添加数据</param> /// <param name="memberMap">成员位图</param> /// <param name="query">添加数据查询信息</param> internal override void insert <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, valueType value, MemberMap <modelType> memberMap, ref InsertQuery query) { CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null); if (sqlStream == null) { sqlStream = new CharStream(null, 0); } byte *buffer = null; try { sqlStream.Reset(buffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize); if (DataModel.Model <modelType> .Identity != null) { long identity; if (sqlTool.Attribute.IsSetIdentity) { DataModel.Model <modelType> .SetIdentity(value, identity = sqlTool.NextIdentity); } else { sqlTool.Identity64 = identity = DataModel.Model <modelType> .GetIdentity(value); } sqlStream.WriteNotNull("insert into`"); sqlStream.WriteNotNull(sqlTool.TableName); sqlStream.WriteNotNull("`("); DataModel.Model <modelType> .Inserter.GetColumnNames(sqlStream, memberMap); sqlStream.WriteNotNull(")values("); DataModel.Model <modelType> .Inserter.Insert(sqlStream, memberMap, value, ConstantConverter.Default, sqlTool); sqlStream.WriteNotNull(");"); query.InsertSql = sqlStream.ToString(); if (!query.NotQuery) { sqlStream.ByteSize = 0; getByIdentity(sqlStream, sqlTool.TableName, value, memberMap); query.Sql = sqlStream.ToString(); } } else { sqlStream.WriteNotNull("insert into`"); sqlStream.WriteNotNull(sqlTool.TableName); sqlStream.WriteNotNull("`("); DataModel.Model <modelType> .Inserter.GetColumnNames(sqlStream, memberMap); sqlStream.WriteNotNull(")values("); DataModel.Model <modelType> .Inserter.Insert(sqlStream, memberMap, value, ConstantConverter.Default, sqlTool); sqlStream.WriteNotNull(");"); query.InsertSql = sqlStream.ToString(); if (!query.NotQuery && DataModel.Model <modelType> .PrimaryKeys.Length != 0) { sqlStream.ByteSize = 0; getByPrimaryKey(sqlStream, sqlTool.TableName, value, memberMap); query.Sql = sqlStream.ToString(); } } } finally { if (buffer != null) { AutoCSer.UnmanagedPool.Default.Push(buffer); } sqlStream.Dispose(); Interlocked.Exchange(ref this.sqlStream, sqlStream); } }
/// <summary> /// 更新数据 /// </summary> /// <typeparam name="valueType">数据类型</typeparam> /// <typeparam name="modelType">模型类型</typeparam> /// <param name="sqlTool">SQL操作工具</param> /// <param name="transaction">事务操作</param> /// <param name="value">匹配成员值</param> /// <param name="memberMap">成员位图</param> /// <param name="query">查询信息</param> /// <returns>更新是否成功</returns> internal override bool Update <valueType, modelType> (Sql.Table <valueType, modelType> sqlTool, Transaction transaction, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query) { if (sqlTool.CallOnUpdate(value, memberMap) && executeNonQuery(transaction, query.UpdateSql) > 0) { sqlTool.CallOnUpdated(transaction, value, memberMap); return(true); } return(false); }
/// <summary> /// 更新数据 /// </summary> /// <typeparam name="valueType">数据类型</typeparam> /// <typeparam name="modelType">模型类型</typeparam> /// <param name="sqlTool">SQL操作工具</param> /// <param name="connection">SQL连接</param> /// <param name="value">匹配成员值</param> /// <param name="memberMap">成员位图</param> /// <param name="query">查询信息</param> /// <returns>更新是否成功</returns> internal override bool Update <valueType, modelType> (Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query) { if (query.NotQuery) { if (executeNonQuery(ref connection, query.UpdateSql) > 0) { sqlTool.CallOnUpdated(value, null, memberMap); return(true); } } else { GetQuery <modelType> getQuery = new GetQuery <modelType> { MemberMap = query.MemberMap, Sql = query.Sql }; valueType oldValue = AutoCSer.Emit.Constructor <valueType> .New(); if (Get(sqlTool, ref connection, oldValue, ref getQuery) && executeNonQuery(connection, query.UpdateSql) > 0 && Get(sqlTool, ref connection, value, ref getQuery)) { sqlTool.CallOnUpdated(value, oldValue, memberMap); return(true); } } return(false); }
public bool Update(valueType value, MemberMap <modelType> memberMap, bool isIgnoreTransaction = false) { valueType cacheLock = this[AutoCSer.Sql.DataModel.Model <modelType> .GetIdentity32(value)]; return(cacheLock != null && SqlTable.UpdateQueue(value, memberMap, isIgnoreTransaction)); }
/// <summary> /// 获取分组数据成员位图 /// </summary> /// <param name="group">分组</param> /// <returns>分组数据成员位图</returns> private static MemberMap <modelType> getGroupMemberMap(int group) { if (groupMemberMaps == null) { LeftArray <KeyValue <MemberMap <modelType>, int> > memberMaps = new LeftArray <KeyValue <MemberMap <modelType>, int> >(); memberMaps.Add(new KeyValue <MemberMap <modelType>, int>(MemberMap, 0)); Monitor.Enter(groupMemberMapLock); if (groupMemberMaps == null) { try { foreach (Field field in Fields) { if (field.DataMember.Group != 0) { int index = memberMaps.Length; foreach (KeyValue <MemberMap <modelType>, int> memberMap in memberMaps.Array) { if (memberMap.Value == field.DataMember.Group || --index == 0) { break; } } if (index == 0) { MemberMap <modelType> memberMap = new MemberMap <modelType>(); memberMaps.Add(new KeyValue <MemberMap <modelType>, int>(memberMap, field.DataMember.Group)); memberMap.SetMember(field.MemberMapIndex); } else { memberMaps.Array[memberMaps.Length - index].Key.SetMember(field.MemberMapIndex); } } } if (memberMaps.Length != 1) { MemberMap <modelType> memberMap = memberMaps.Array[0].Key = new MemberMap <modelType>(); foreach (Field field in Fields) { if (field.DataMember.Group == 0) { memberMap.SetMember(field.MemberMapIndex); } } } groupMemberMaps = memberMaps.ToArray(); } finally { Monitor.Exit(groupMemberMapLock); } } else { Monitor.Exit(groupMemberMapLock); } } foreach (KeyValue <MemberMap <modelType>, int> memberMap in groupMemberMaps) { if (memberMap.Value == group) { return(memberMap.Key); } } AutoCSer.Log.Pub.Log.Add(AutoCSer.Log.LogType.Error, typeof(modelType).fullName() + " 缺少缓存分组 " + group.toString()); return(null); }
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap) { onDeleted(oldValue); onInserted(cacheValue); }
public ValidationContext(TypePair types, MemberMap memberMap, IObjectMapper objectMapper) : this(types, memberMap, objectMapper, null) { }
private void onUpdated(valueType value, valueType oldValue, MemberMap <modelType> memberMap) { onInserted(value); onDeleted(oldValue); }
public ValidationContext(TypePair types, MemberMap memberMap, TypeMap typeMap) : this(types, memberMap, null, typeMap) { }
public Expression MapExpression(IGlobalConfiguration configurationProvider, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression) => Expression.Call(destExpression.Type.GetMethod("Parse", new[] { typeof(string) }), sourceExpression);
private void DryRunTypeMap(ICollection <TypeMap> typeMapsChecked, TypePair types, TypeMap typeMap, MemberMap memberMap) { if (typeMap == null) { if (types.ContainsGenericParameters) { return; } typeMap = _config.ResolveTypeMap(types.SourceType, types.DestinationType); } if (typeMap != null) { if (typeMapsChecked.Contains(typeMap)) { return; } typeMapsChecked.Add(typeMap); var context = new ValidationContext(types, memberMap, typeMap); Validate(context); if (!typeMap.ShouldCheckForValid) { return; } CheckPropertyMaps(typeMapsChecked, typeMap); typeMap.IsValid = true; } else { var mapperToUse = _config.FindMapper(types); if (mapperToUse == null) { throw new AutoMapperConfigurationException(memberMap.TypeMap.Types) { MemberMap = memberMap }; } var context = new ValidationContext(types, memberMap, mapperToUse); Validate(context); if (mapperToUse is IObjectMapperInfo mapperInfo) { var newTypePair = mapperInfo.GetAssociatedTypes(types); if (newTypePair != types) { DryRunTypeMap(typeMapsChecked, newTypePair, null, memberMap); } } } }
/// <summary> /// Creates an expression the represents getting the field for the given /// member and converting it to the member's type. /// </summary> /// <param name="memberMap">The mapping for the member.</param> public virtual Expression CreateGetFieldExpression(MemberMap memberMap) { if (memberMap.Data.ReadingConvertExpression != null) { // The user is providing the expression to do the conversion. Expression exp = Expression.Invoke(memberMap.Data.ReadingConvertExpression, Expression.Constant(new ConvertFromStringArgs { Row = reader })); return(Expression.Convert(exp, memberMap.Data.Member.MemberType())); } if (!reader.CanRead(memberMap)) { return(null); } if (memberMap.Data.TypeConverter == null) { // Skip if the type isn't convertible. return(null); } int index; if (memberMap.Data.IsNameSet || reader.Configuration.HasHeaderRecord && !memberMap.Data.IsIndexSet) { // Use the name. index = reader.GetFieldIndex(memberMap.Data.Names.ToArray(), memberMap.Data.NameIndex, memberMap.Data.IsOptional); if (index == -1) { if (memberMap.Data.IsDefaultSet) { return(CreateDefaultExpression(memberMap, Expression.Constant(string.Empty))); } // Skip if the index was not found. return(null); } } else { // Use the index. index = memberMap.Data.Index; } // Get the field using the field index. var method = typeof(IReaderRow).GetProperty("Item", typeof(string), new[] { typeof(int) }).GetGetMethod(); Expression fieldExpression = Expression.Call(Expression.Constant(reader), method, Expression.Constant(index, typeof(int))); // Validate the field. if (memberMap.Data.ValidateExpression != null) { var constructor = typeof(ValidateArgs).GetConstructor(new Type[] { typeof(string) }); var args = Expression.New(constructor, fieldExpression); var validateExpression = Expression.IsFalse(Expression.Invoke(memberMap.Data.ValidateExpression, args)); var validationExceptionConstructor = typeof(FieldValidationException).GetConstructors().OrderBy(c => c.GetParameters().Length).First(); var newValidationExceptionExpression = Expression.New(validationExceptionConstructor, Expression.Constant(reader.Context), fieldExpression); var throwExpression = Expression.Throw(newValidationExceptionExpression); fieldExpression = Expression.Block( // If the validate method returns false, throw an exception. Expression.IfThen(validateExpression, throwExpression), fieldExpression ); } if (memberMap.Data.IsConstantSet) { fieldExpression = Expression.Convert(Expression.Constant(memberMap.Data.Constant), memberMap.Data.Member.MemberType()); } else if (memberMap.Data.IsDefaultSet) { return(CreateDefaultExpression(memberMap, fieldExpression)); } else { fieldExpression = CreateTypeConverterExpression(memberMap, fieldExpression); } return(fieldExpression); }
/// <summary> /// 更新数据 /// </summary> /// <param name="cacheValue"></param> /// <param name="value">更新后的数据</param> /// <param name="oldValue">更新前的数据</param> /// <param name="memberMap"></param> protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap) { keyType key = getKey(value), oldKey = getKey(oldValue); if (!key.Equals(oldKey)) { Array.Add(key, cacheValue); Array.Remove(oldKey, out value); if (value == null) { cache.SqlTable.Log.add(AutoCSer.Log.LogType.Fatal, typeof(valueType).FullName + " 缓存同步错误"); } } }
public void SetUp() { _sut = new MemberAccess(); _mapper = new MemberMap(); }
public Expression MapExpression(IGlobalConfiguration configurationProvider, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression) => Call(MapMethodInfo, sourceExpression, destExpression.ToObject(), Constant(destExpression.Type), ContextParameter, Constant(profileMap));
public void EmitMemberMap(LocalBuilderWrapper fromLocal, LocalBuilderWrapper toLocal, MemberMap memberMap, HashSet <Type> convertedTypes) { var skipMemberMap = this.DefineLabel(); if (memberMap.FromMember.NeedsContainsCheck) { var containsKey = fromLocal.LocalType.GetMethod("ContainsKey", new[] { typeof(string) }); this.EmitLocal(fromLocal.LocalType.IsValueType ? OpCodes.Ldloca : OpCodes.Ldloc, fromLocal); this.EmitString(memberMap.FromMember.Name); this.EmitCall(OpCodes.Call, containsKey); this.EmitBreak(OpCodes.Brfalse, skipMemberMap); } // Load toLocal as parameter for the setter this.EmitLocal(toLocal.LocalType.IsValueType ? OpCodes.Ldloca : OpCodes.Ldloc, toLocal); if (memberMap.ToMember.NeedsStringIndex) { this.EmitString(memberMap.ToMember.Name); } // Load fromLocal as parameter for the getter this.EmitLocal(fromLocal.LocalType.IsValueType ? OpCodes.Ldloca : OpCodes.Ldloc, fromLocal); if (memberMap.FromMember.MemberInfo is PropertyInfo) { var getter = (memberMap.FromMember.MemberInfo as PropertyInfo).GetGetMethod(); if (memberMap.FromMember.MemberType == MemberType.StringIndexer) { this.EmitString(memberMap.FromMember.Name); } this.EmitCall(OpCodes.Callvirt, getter); } else if (memberMap.FromMember.MemberInfo is FieldInfo) { this.EmitField(OpCodes.Ldfld, memberMap.FromMember.MemberInfo as FieldInfo); } else if (memberMap.FromMember.MemberInfo is MethodInfo) { var method = memberMap.FromMember.MemberInfo as MethodInfo; if (memberMap.FromMember.NeedsStringIndex) { this.EmitString(memberMap.FromMember.Name); } this.EmitCall(OpCodes.Callvirt, method); } // Convert the value on top of the stack to the correct toType this.EmitConvertValue(memberMap.FromMember.Type, memberMap.ToMember.Type, new HashSet <Type>(convertedTypes)); if (memberMap.ToMember.MemberInfo is PropertyInfo) { var setter = (memberMap.ToMember.MemberInfo as PropertyInfo).GetSetMethod(); this.EmitCall(OpCodes.Callvirt, setter); } else if (memberMap.ToMember.MemberInfo is FieldInfo) { this.EmitField(OpCodes.Stfld, memberMap.ToMember.MemberInfo as FieldInfo); } else if (memberMap.ToMember.MemberInfo is MethodInfo) { this.EmitCall(OpCodes.Call, memberMap.ToMember.MemberInfo as MethodInfo); } if (memberMap.FromMember.NeedsContainsCheck) { this.MarkLabel(skipMemberMap); } }
/// <summary> /// Applies configuration to the given <see cref="MemberMap" />. /// </summary> /// <param name="memberMap">The member map.</param> public void ApplyTo(MemberMap memberMap) { memberMap.Data.NameIndex = NameIndex; }
/// <summary> /// Creates an expression the represents getting the field for the given /// member and converting it to the member's type. /// </summary> /// <param name="memberMap">The mapping for the member.</param> public virtual Expression CreateGetFieldExpression(MemberMap memberMap) { if (memberMap.Data.ReadingConvertExpression != null) { // The user is providing the expression to do the conversion. Expression exp = Expression.Invoke(memberMap.Data.ReadingConvertExpression, Expression.Constant(reader)); return(Expression.Convert(exp, memberMap.Data.Member.MemberType())); } if (!reader.CanRead(memberMap)) { return(null); } if (memberMap.Data.TypeConverter == null) { // Skip if the type isn't convertible. return(null); } int index; if (memberMap.Data.IsNameSet || reader.Context.ReaderConfiguration.HasHeaderRecord && !memberMap.Data.IsIndexSet) { // Use the name. index = reader.GetFieldIndex(memberMap.Data.Names.ToArray(), memberMap.Data.NameIndex, memberMap.Data.IsOptional); if (index == -1) { // Skip if the index was not found. return(null); } } else { // Use the index. index = memberMap.Data.Index; } // Get the field using the field index. var method = typeof(IReaderRow).GetProperty("Item", typeof(string), new[] { typeof(int) }).GetGetMethod(); Expression fieldExpression = Expression.Call(Expression.Constant(reader), method, Expression.Constant(index, typeof(int))); // Validate the field. if (memberMap.Data.ValidateExpression != null) { var validateExpression = Expression.IsFalse(Expression.Invoke(memberMap.Data.ValidateExpression, fieldExpression)); var validationExceptionConstructor = typeof(ValidationException).GetConstructors().OrderBy(c => c.GetParameters().Length).First(); var throwExpression = Expression.Throw(Expression.Constant(new ValidationException(reader.Context))); fieldExpression = Expression.Block( // If the validate method returns false, throw an exception. Expression.IfThen(validateExpression, throwExpression), fieldExpression ); } // Convert the field. var typeConverterExpression = Expression.Constant(memberMap.Data.TypeConverter); memberMap.Data.TypeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions { CultureInfo = reader.Context.ReaderConfiguration.CultureInfo }, reader.Context.ReaderConfiguration.TypeConverterOptionsCache.GetOptions(memberMap.Data.Member.MemberType()), memberMap.Data.TypeConverterOptions); // Create type converter expression. Expression typeConverterFieldExpression = Expression.Call(typeConverterExpression, nameof(ITypeConverter.ConvertFromString), null, fieldExpression, Expression.Constant(reader), Expression.Constant(memberMap.Data)); typeConverterFieldExpression = Expression.Convert(typeConverterFieldExpression, memberMap.Data.Member.MemberType()); if (memberMap.Data.IsConstantSet) { fieldExpression = Expression.Convert(Expression.Constant(memberMap.Data.Constant), memberMap.Data.Member.MemberType()); } else if (memberMap.Data.IsDefaultSet) { // Create default value expression. Expression defaultValueExpression; if (memberMap.Data.Member.MemberType() != typeof(string) && memberMap.Data.Default != null && memberMap.Data.Default.GetType() == typeof(string)) { // The default is a string but the member type is not. Use a converter. defaultValueExpression = Expression.Call(typeConverterExpression, nameof(ITypeConverter.ConvertFromString), null, Expression.Constant(memberMap.Data.Default), Expression.Constant(reader), Expression.Constant(memberMap.Data)); } else { // The member type and default type match. defaultValueExpression = Expression.Constant(memberMap.Data.Default); } defaultValueExpression = Expression.Convert(defaultValueExpression, memberMap.Data.Member.MemberType()); // If null, use string.Empty. var coalesceExpression = Expression.Coalesce(fieldExpression, Expression.Constant(string.Empty)); // Check if the field is an empty string. var checkFieldEmptyExpression = Expression.Equal(Expression.Convert(coalesceExpression, typeof(string)), Expression.Constant(string.Empty, typeof(string))); // Use a default value if the field is an empty string. fieldExpression = Expression.Condition(checkFieldEmptyExpression, defaultValueExpression, typeConverterFieldExpression); } else { fieldExpression = typeConverterFieldExpression; } return(fieldExpression); }
/// <summary> /// 查询对象 /// </summary> /// <typeparam name="modelType">模型类型</typeparam> /// <param name="sqlStream"></param> /// <param name="tableName"></param> /// <param name="value"></param> /// <param name="memberMap"></param> private void getByPrimaryKey <modelType>(CharStream sqlStream, string tableName, modelType value, MemberMap <modelType> memberMap) where modelType : class { sqlStream.WriteNotNull("select "); DataModel.Model <modelType> .GetNames(sqlStream, memberMap); sqlStream.WriteNotNull(" from `"); sqlStream.WriteNotNull(tableName); sqlStream.WriteNotNull("` where "); DataModel.Model <modelType> .PrimaryKeyWhere.Write(sqlStream, value, ConstantConverter.Default); sqlStream.WriteNotNull(" limit 0,1;"); }