private new void onUpdated(valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
if (isValue(value))
{
base.onUpdated(value, oldValue, memberMap);
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="memberMap">更新成员位图</param>
protected void onUpdated(valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
valueType cacheValue = values[GetKey(value)];
update(cacheValue, value, oldValue, memberMap);
callOnUpdated(cacheValue, value, oldValue, memberMap);
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="memberMap">更新成员位图</param>
private void onUpdated(valueType value, valueType oldValue, fastCSharp.code.memberMap<modelType> memberMap)
{
valueType cacheValue = getMember(getValue(GetKey(value)));
if (cacheValue != null)
{
update(cacheValue, value, oldValue, memberMap);
callOnUpdated(cacheValue, value, oldValue, memberMap);
}
else log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
/// <summary>
/// SQL操作缓存
/// </summary>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="group">数据分组</param>
protected sqlTool(fastCSharp.emit.sqlTable.sqlTool <valueType, modelType> sqlTool, int group)
{
if (sqlTool == null)
{
log.Error.Throw(log.exceptionType.Null);
}
memberGroup = group;
SqlTool = sqlTool;
memberMap = fastCSharp.emit.sqlModel <modelType> .GetCacheMemberMap(group);
}
public static valueType Copy <valueType>(this valueType value, fastCSharp.code.memberMap <valueType> memberMap = null)
where valueType : class
{
if (value == null)
{
return(null);
}
valueType newValue = fastCSharp.emit.constructor <valueType> .New();
fastCSharp.emit.memberCopyer <valueType> .Copy(newValue, value, memberMap);
return(newValue);
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="memberMap">更新成员位图</param>
private void onUpdated(valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
valueType cacheValue;
if (dictionary.Value.TryGetValue(GetKey(value), out cacheValue))
{
update(cacheValue, value, oldValue, memberMap);
callOnUpdated(cacheValue, value, oldValue, memberMap);
}
else
{
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
/// <summary>
/// 更新缓存数据
/// </summary>
/// <param name="value">缓存数据</param>
/// <param name="newValue">更新后的新数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="updateMemberMap">更新成员位图</param>
protected void update(valueType value, valueType newValue, valueType oldValue, fastCSharp.code.memberMap <modelType> updateMemberMap)
{
using (fastCSharp.code.memberMap <modelType> memberMap = this.memberMap.Copy())
{
memberMap.And(updateMemberMap);
fastCSharp.emit.memberCopyer <modelType> .Copy(value, newValue, memberMap);
memberMap.Xor(this.memberMap);
memberMap.And(this.memberMap);
fastCSharp.emit.memberCopyer <modelType> .Copy(oldValue, value, memberMap);
fastCSharp.emit.memberCopyer <modelType> .Copy(newValue, value, memberMap);
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="memberMap">更新成员位图</param>
private void onUpdated(valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
keyValue <valueType, int> cacheValue;
keyType key = GetKey(value);
if (values.TryGetValue(key, out cacheValue))
{
update(cacheValue.Key, value, oldValue, memberMap);
}
if (OnUpdated != null)
{
OnUpdated(cacheValue.Key, value, oldValue, memberMap);
}
}
///// <summary>
///// 更新数据
///// </summary>
///// <param name="value">更新后的数据</param>
///// <param name="oldValue">更新前的数据</param>
///// <param name="memberMap">更新成员位图</param>
//private void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap<modelType> memberMap)
//{
// targetType memberCache = getValue(cacheValue);
// keyValue<valueType, int> cache = GetMember(memberCache);
// if (cache.Key != null) update(cache.Key, value, memberMap);
// if (OnUpdated != null) OnUpdated(cache.Key, value, oldValue);
//}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="memberMap">更新成员位图</param>
private void onUpdated(valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
targetType memberCache = GetByKey(GetKey(value));
keyValue <valueType, int> cache = GetMember(memberCache);
if (cache.Key != null)
{
update(cache.Key, value, oldValue, memberMap);
}
if (OnUpdated != null)
{
OnUpdated(cache.Key, value, oldValue, memberMap);
}
}
/// <summary>
/// 查询对象集合
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="query">查询信息</param>
/// <param name="memberMap">成员位图</param>
/// <param name="sqlStream"></param>
/// <returns></returns>
private unsafe string selectRows <valueType, modelType>
(fastCSharp.emit.sqlTable.sqlTool <valueType, modelType> sqlTool, selectQuery <modelType> query, fastCSharp.code.memberMap <modelType> memberMap, charStream sqlStream)
where valueType : class, modelType
where modelType : class
{
pointer buffer = fastCSharp.sql.client.SqlBuffers.Get();
try
{
using (sqlStream)
{
sqlStream.UnsafeReset(buffer.Byte, SqlBufferSize << 1);
sqlStream.WriteNotNull("select * from(select ");
sqlModel <modelType> .GetNames(sqlStream, memberMap);
sqlStream.WriteNotNull(",row_number()over(");
query.WriteOrder(sqlTool, sqlStream);
sqlStream.SimpleWriteNotNull(")as ");
sqlStream.SimpleWriteNotNull(orderOverName);
sqlStream.SimpleWriteNotNull(" from[");
sqlStream.SimpleWriteNotNull(sqlTool.TableName);
sqlStream.SimpleWriteNotNull("]with(nolock)");
if (query.WriteWhereOnly(sqlTool, sqlStream))
{
sqlStream.SimpleWriteNotNull(")as T where ");
sqlStream.SimpleWriteNotNull(orderOverName);
sqlStream.SimpleWriteNotNull(" between ");
number.ToString(query.SkipCount, sqlStream);
sqlStream.SimpleWriteNotNull(" and ");
number.ToString(query.SkipCount + query.GetCount - 1, sqlStream);
return(sqlStream.ToString());
}
}
}
finally { fastCSharp.sql.client.SqlBuffers.Push(ref buffer); }
return(null);
}
public bool Update(valueType value, fastCSharp.code.memberMap <modelType> memberMap, bool isIgnoreTransaction = false)
{
valueType cacheLock = this[fastCSharp.emit.sqlModel <modelType> .GetIdentity32(value)];
return(cacheLock != null && SqlTool.Client.UpdateByIdentity(SqlTool, value, memberMap, cacheLock, isIgnoreTransaction));
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
keyType oldKey = getKey(oldValue), newKey = getKey(value);
if (newKey.Equals(oldKey))
{
valueKeyType oldValueKey = getValueKey(oldValue), newValueKey = getValueKey(value);
if (!oldValueKey.Equals(newValueKey))
{
targetType target = getValue(newKey);
if (target == null)
{
log.Error.Add(typeof(valueType).FullName + " 没有找到缓存目标对象 " + newKey.ToString(), new System.Diagnostics.StackFrame(), true);
}
else
{
Dictionary <randomKey <valueKeyType>, valueType> dictionary = GetMember(target);
if (dictionary != null)
{
if (dictionary.Remove(oldValueKey))
{
dictionary.Add(newValueKey, cacheValue);
return;
}
dictionary.Add(newValueKey, cacheValue);
}
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
}
else
{
onInserted(cacheValue, newKey);
onDeleted(oldValue, oldKey);
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.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)
{
log.Error.Add(typeof(valueType).FullName + " 没有找到缓存目标对象 " + key.ToString(), new System.Diagnostics.StackFrame(), true);
}
else
{
list <valueType>[] lists = GetMember(target);
if (lists != null)
{
list <valueType> list = lists[index];
if (list == null)
{
lists[index] = list = new list <valueType>();
}
list.Add(cacheValue);
if ((list = lists[oldIndex]) != null)
{
index = Array.LastIndexOf(list.UnsafeArray, cacheValue, list.Count - 1);
if (index != -1)
{
if (isRemoveEnd)
{
list.RemoveAtEnd(index);
}
else
{
list.RemoveAt(index);
}
return;
}
}
}
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
}
else
{
onInserted(cacheValue, key, index);
onDeleted(cacheValue, oldKey, oldIndex);
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
int index = getIndex(value), oldIndex = getIndex(oldValue);
if (index == oldIndex)
{
sortType sortKey = getSort(value), oldSortKey = getSort(oldValue);
if (!sortKey.Equals(oldSortKey))
{
fastCSharp.searchTree <sortType, valueType> tree = array[index].Value;
if (tree != null)
{
++array[index].Version;
try
{
if (tree.Remove(oldSortKey))
{
tree.Add(sortKey, cacheValue);
return;
}
}
finally { ++array[index].Version; }
}
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
else
{
onInserted(cacheValue, index);
onDeleted(oldValue, oldIndex);
}
}
/// <summary>
/// 查询对象集合
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="query">查询信息</param>
/// <param name="memberMap">成员位图</param>
/// <param name="onGet"></param>
public override void Select <valueType, modelType>
(fastCSharp.emit.sqlTable.sqlTool <valueType, modelType> sqlTool, selectQuery <modelType> query, fastCSharp.code.memberMap <modelType> memberMap, Action <subArray <valueType> > onGet)
{
if (onGet == null)
{
log.Error.Throw(log.exceptionType.Null);
}
subArray <valueType> values = default(subArray <valueType>);
try
{
selector <valueType, modelType> selector = selector <valueType, modelType> .Get();
if (selector != null)
{
selector.MemberMap.CopyFrom(fastCSharp.emit.sqlModel <modelType> .MemberMap);
if (memberMap != null && !memberMap.IsDefault)
{
selector.MemberMap.And(memberMap);
}
if (query != null && query.SkipCount != 0 && query.Orders.length() != 0)
{
if (sqlModel <modelType> .PrimaryKeys.Length == 1)
{
string sql = selectKeys(sqlTool, query, sqlModel <modelType> .PrimaryKeys[0].SqlFieldName, selector.MemberMap, selector.SqlStream);
if (sql != null)
{
selector.Get(this, sql, 0, ref onGet);
return;
}
values.array = nullValue <valueType> .Array;
}
else if (sqlModel <modelType> .Identity != null)
{
string sql = selectKeys(sqlTool, query, sqlModel <modelType> .Identity.SqlFieldName, selector.MemberMap, selector.SqlStream);
if (sql != null)
{
selector.Get(this, sql, 0, ref onGet);
return;
}
values.array = nullValue <valueType> .Array;
}
else
{
string sql = selectRows(sqlTool, query, selector.MemberMap, selector.SqlStream);
if (sql != null)
{
selector.Get(this, sql, 0, ref onGet);
return;
}
values.array = nullValue <valueType> .Array;
}
}
if (values.array == null)
{
string sql = selectNoOrder(sqlTool, query, selector.MemberMap, selector.SqlStream);
if (sql != null)
{
selector.Get(this, sql, query == null ? 0 : query.SkipCount, ref onGet);
return;
}
values.array = nullValue <valueType> .Array;
}
typePool <selector <valueType, modelType> > .PushNotNull(selector);
}
}
finally
{
if (onGet != null)
{
onGet(values);
}
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
keyType key = getKey(value), oldKey = getKey(oldValue);
if (key.Equals(oldKey))
{
group values;
if (indexOf(cacheValue, key, out values) == -1)
{
log.Error.Add("ERROR " + key.ToString(), new System.Diagnostics.StackFrame(), false);
}
}
else
{
onInserted(cacheValue);
onDeleted(cacheValue, oldKey);
}
}
private new void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
onInserted(cacheValue);
}
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
Append(getTime(value));
}
/// <summary>
/// 查询对象集合
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="query">查询信息</param>
/// <param name="memberMap">成员位图</param>
/// <returns>对象集合</returns>
private unsafe IEnumerable <valueType> selectRowsPushMemberMap <valueType, modelType>
(fastCSharp.emit.sqlTable.sqlTool <valueType, modelType> sqlTool, selectQuery <modelType> query, fastCSharp.code.memberMap <modelType> memberMap)
where valueType : class, modelType
where modelType : class
{
string sql = selectRows(sqlTool, query, memberMap, new charStream((char *)fastCSharp.emit.pub.PuzzleValue, 1));
return(sql != null?selectPushMemberMap <valueType, modelType>(sql, 0, memberMap) : nullValue <valueType> .Array);
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="cacheValue">缓存数据</param>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
private void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
keyType key = getKey(value);
if (cacheValue == null)
{
list <valueType> values;
if (queueCache.Remove(key, out values))
{
foreach (valueType removeValue in values)
{
counter.Remove(removeValue);
}
}
}
else
{
keyType oldKey = getKey(oldValue);
if (!key.Equals(oldKey))
{
list <valueType> values = queueCache.Get(key, null), oldValues = queueCache.Get(oldKey, null);
if (values != null)
{
if (oldValues != null)
{
values.Add(cacheValue);
if (!oldValues.Remove(cacheValue))
{
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
else
{
values.Add(counter.Add(cacheValue));
}
}
else if (oldValues != null)
{
if (oldValues.Remove(cacheValue))
{
counter.Remove(cacheValue);
}
else
{
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
}
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="cacheValue">缓存数据</param>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
private void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
keyType key = getKey(value);
if (cacheValue == null)
{
Dictionary <randomKey <dictionaryKeyType>, valueType> values;
if (queueCache.Remove(key, out values))
{
foreach (valueType removeValue in values.Values)
{
counter.Remove(removeValue);
}
}
}
else
{
keyType oldKey = getKey(oldValue);
if (key.Equals(oldKey))
{
Dictionary <randomKey <dictionaryKeyType>, valueType> values = queueCache.Get(key, null);
if (values != null)
{
dictionaryKeyType dictionaryKey = getDictionaryKey(cacheValue), oldDictionaryKey = getDictionaryKey(oldValue);
if (!dictionaryKey.Equals(oldDictionaryKey))
{
values.Add(dictionaryKey, cacheValue);
values.Remove(oldDictionaryKey);
}
}
}
else
{
Dictionary <randomKey <dictionaryKeyType>, valueType> values = queueCache.Get(key, null);
Dictionary <randomKey <dictionaryKeyType>, valueType> oldValues = queueCache.Get(oldKey, null);
if (values != null)
{
if (oldValues != null)
{
values.Add(getDictionaryKey(cacheValue), cacheValue);
if (!oldValues.Remove(getDictionaryKey(oldValue)))
{
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
else
{
values.Add(getDictionaryKey(cacheValue), counter.Add(cacheValue));
}
}
else if (oldValues != null)
{
if (oldValues.Remove(getDictionaryKey(value)))
{
counter.Remove(cacheValue);
}
else
{
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
}
}
}
protected void callOnUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
if (OnUpdated != null)
{
OnUpdated(cacheValue, value, oldValue, memberMap);
}
}
/// <summary>
/// 修改学生处理
/// </summary>
/// <param name="cacheValue">当前缓存对象</param>
/// <param name="value">修改之后的对象数据</param>
/// <param name="oldValue">修改之前的对象数据</param>
/// <param name="memberMap">被修改成员位图</param>
private static void onUpdated(Student cacheValue, Student value, Student oldValue, fastCSharp.code.memberMap <sqlModel.Student> memberMap)
{
if (memberIndexs.Classes.IsMember(memberMap))
{
Class Class = Class.Cache[oldValue.ClassId];
if (Class != null)
{
Class.SqlStreamLoad.StudentCount(Class.StudentCount - 1);
}
onInserted(cacheValue);
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="cacheValue">缓存数据</param>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
private void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
keyType key = getKey(value);
if (cacheValue == null)
{
cacheValueType values;
if (queueCache.Remove(key, out values))
{
foreach (valueType removeValue in values.Values)
{
counter.Remove(removeValue);
}
}
}
else
{
keyType oldKey = getKey(oldValue);
cacheValueType values = queueCache.Get(key, null);
if (key.Equals(oldKey))
{
if (values != null)
{
int updateValue = values.Update(cacheValue, oldValue);
if (updateValue != 0)
{
if (updateValue > 1)
{
counter.Add(cacheValue);
}
else
{
counter.Remove(cacheValue);
}
}
}
}
else
{
cacheValueType oldValues = queueCache.Get(oldKey, null);
if (values != null)
{
if (oldValues != null)
{
if (oldValues.Remove(oldValue))
{
if (!values.Add(cacheValue))
{
counter.Remove(cacheValue);
}
}
else if (values.Add(cacheValue))
{
counter.Add(cacheValue);
}
}
else if (values.Add(cacheValue))
{
counter.Add(cacheValue);
}
}
else if (oldValues != null && oldValues.Remove(oldValue))
{
counter.Remove(cacheValue);
}
}
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
protected virtual void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
keyType key = getKey(value), oldKey = getKey(oldValue);
if (!key.Equals(oldKey))
{
onInserted(cacheValue, key);
onDeleted(oldKey);
}
}
/// <summary>
/// 查询对象集合
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="query">查询信息</param>
/// <param name="memberMap">成员位图</param>
/// <returns>对象集合</returns>
protected override IEnumerable <valueType> selectPushMemberMap <valueType, modelType>
(fastCSharp.emit.sqlTable.sqlTool <valueType, modelType> sqlTool, selectQuery <modelType> query, fastCSharp.code.memberMap <modelType> memberMap)
{
if (query != null && query.SkipCount != 0 && query.Orders.length() != 0)
{
if (sqlModel <modelType> .PrimaryKeys.Length == 1)
{
return(selectKeysPushMemberMap(sqlTool, query, sqlModel <modelType> .PrimaryKeys[0].SqlFieldName, memberMap));
}
if (sqlModel <modelType> .Identity != null)
{
return(selectKeysPushMemberMap(sqlTool, query, sqlModel <modelType> .Identity.SqlFieldName, memberMap));
}
return(selectRowsPushMemberMap(sqlTool, query, memberMap));
}
return(selectNoOrderPushMemberMap(sqlTool, query, memberMap));
}
private void onUpdated(valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
onInserted(value);
onDeleted(oldValue);
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
groupKeyType groupKey = getGroupKey(value), oldGroupKey = getGroupKey(oldValue);
if (groupKey.Equals(oldGroupKey))
{
keyType key = getKey(value), oldKey = getKey(oldValue);
if (!key.Equals(oldKey))
{
Dictionary <randomKey <keyType>, valueType> dictionary;
if (groups.TryGetValue(groupKey, out dictionary) && dictionary.Remove(oldKey))
{
dictionary.Add(key, cacheValue);
}
else
{
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
}
else
{
onInserted(cacheValue, groupKey);
onDeleted(oldValue, oldGroupKey);
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
private new void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.memberMap <modelType> memberMap)
{
if (isValue(value))
{
if (isValue(oldValue))
{
base.onUpdated(cacheValue, value, oldValue, memberMap);
}
else
{
base.onInserted(cacheValue);
}
}
else if (isValue(oldValue))
{
base.onDeleted(oldValue);
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, fastCSharp.code.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)
{
log.Error.Add(typeof(valueType).FullName + " 没有找到缓存目标对象 " + key.ToString(), new System.Diagnostics.StackFrame(), true);
}
else
{
ladyOrderArray <valueType>[] arrays = GetMember(target);
if (arrays != null)
{
ladyOrderArray <valueType> array = arrays[index];
if (array == null)
{
arrays[index] = array = new ladyOrderArray <valueType>();
}
array.Insert(cacheValue);
if ((array = arrays[oldIndex]) != null)
{
array.Delete(cacheValue);
return;
}
}
log.Error.Add(typeof(valueType).FullName + " 缓存同步错误", null, true);
}
}
}
else
{
onInserted(cacheValue, key, index);
onDeleted(cacheValue, oldKey, getIndex(oldValue));
}
}
