private static object DeserializeJsonObject(SchemaTable schemaTable, AbstractEntity entity, object value,
SchemaColumn fieldAttr, string columnName)
{
try
{
if (fieldAttr.ColumnType.IsSubclassOf(typeof(Array)))
{
value = value.ToString().StartsWith("[") ? value : "[" + value + "]";
}
string tempValue = value.ToNotNullString();
if (!string.IsNullOrEmpty(fieldAttr.JsonDateTimeFormat) &&
tempValue.IndexOf(@"\/Date(") == -1)
{
return(JsonUtils.DeserializeCustom(tempValue, fieldAttr.ColumnType, fieldAttr.JsonDateTimeFormat));
}
else
{
return(JsonUtils.Deserialize(tempValue, fieldAttr.ColumnType));
}
}
catch (Exception ex)
{
TraceLog.WriteError("Table:{0} key:{1} column:{2} deserialize json error:{3} to {4}\r\nException:{5}",
schemaTable.EntityName,
entity.GetKeyCode(),
columnName,
value,
fieldAttr.ColumnType.FullName,
ex);
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="trans"></param>
/// <param name="dataList"></param>
/// <returns></returns>
public static void TransUpdateEntity(IRedisTransaction trans, IEnumerable <AbstractEntity> dataList)
{
var groupList = dataList.GroupBy(t => t.GetType().FullName);
foreach (var g in groupList)
{
string typeName = g.Key;
var keys = new List <byte[]>();
var values = new List <byte[]>();
var removeKeys = new List <byte[]>();
var enm = g.GetEnumerator();
while (enm.MoveNext())
{
AbstractEntity entity = enm.Current;
string keyCode = entity.GetKeyCode();
var keybytes = ToByteKey(keyCode);
if (entity.IsDelete)
{
removeKeys.Add(keybytes);
continue;
}
entity.Reset();
keys.Add(keybytes);
values.Add(_serializer.Serialize(entity));
}
TransUpdateEntity(trans, typeName, keys.ToArray(), values.ToArray(), removeKeys.ToArray());
}
}
internal static string GenerateEntityKey(AbstractEntity entity)
{
if (entity == null)
{
return(string.Empty);
}
return(string.Format("{0}_{1}|{2}",
RedisConnectionPool.EncodeTypeName(entity.GetType().FullName),
entity.PersonalId,
entity.GetKeyCode()));
}
private static string GetQueueFormatKey(AbstractEntity entity)
{
if (entity == null)
{
return(string.Empty);
}
return(string.Format("{0}_{1}|{2}",
RedisConnectionPool.EncodeTypeName(entity.GetType().FullName),
entity.GetIdentityId(),
entity.GetKeyCode()));
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public static void TransSend(AbstractEntity entity)
{
//watch post entity changed times.
ProfileManager.PostEntityOfMessageQueueTimes(entity.GetType().FullName, entity.GetKeyCode(), GetOperateMode(entity));
entity.TempTimeModify = MathUtils.Now;
string key = GetQueueFormatKey(entity);
if (!entity.IsInCache)
{
CacheFactory.AddOrUpdateEntity(key, entity);
}
lock (entitySyncRoot)
{
_entitySet.Add(key);
if (entity.IsDelete)
{
_entityRemoteSet.Add(key);
}
}
}
/// <summary>
/// Try update entity
/// </summary>
/// <param name="dataList"></param>
/// <returns></returns>
public static bool TryUpdateEntity(IEnumerable <AbstractEntity> dataList)
{
var groupList = dataList.GroupBy(t => t.GetType().FullName);
foreach (var g in groupList)
{
string typeName = g.Key;
string redisKey = typeName;
try
{
var keys = new List <byte[]>();
var values = new List <byte[]>();
var removeKeys = new List <byte[]>();
var enm = g.GetEnumerator();
while (enm.MoveNext())
{
AbstractEntity entity = enm.Current;
string keyCode = entity.GetKeyCode();
var keybytes = ToByteKey(keyCode);
redisKey += EntityKeySplitChar + keyCode;
if (entity.IsDelete)
{
removeKeys.Add(keybytes);
continue;
}
entity.Reset();
keys.Add(keybytes);
values.Add(_serializer.Serialize(entity));
}
UpdateEntity(typeName, keys.ToArray(), values.ToArray(), removeKeys.ToArray());
return(true);
}
catch (Exception ex)
{
TraceLog.WriteError("Update entity \"{0}\" error:{1}", redisKey, ex);
}
}
return(false);
}
private object DeserializeBinaryObject(SchemaTable schemaTable, AbstractEntity entity, object value, SchemaColumn fieldAttr, string columnName)
{
try
{
if (value is byte[])
{
byte[] buffer = value as byte[];
return(ProtoBufUtils.Deserialize(buffer, fieldAttr.ColumnType));
}
throw new Exception("value is not byte[] type.");
}
catch (Exception ex)
{
TraceLog.WriteError("Table:{0} key:{1} column:{2} deserialize binary error:byte[] to {3}\r\nException:{4}",
schemaTable.EntityName,
entity.GetKeyCode(),
columnName,
fieldAttr.ColumnType.FullName,
ex);
}
return(null);
}
/// <summary>
/// entity data send to client
/// </summary>
/// <param name="sender"></param>
/// <param name="eventargs"></param>
public static void OnChange(AbstractEntity sender, CacheItemEventArgs eventargs)
{
try
{
if (sender == null ||
(sender as BaseEntity) == null ||
!sender.GetSchema().IsEntitySync)
{
return;
}
string key = sender.GetKeyCode();
if (!_syncPools.ContainsKey(key))
{
_syncPools[key] = true;
_sendQueue.Enqueue(sender as BaseEntity);
singal.Set();
}
}
catch (Exception ex)
{
TraceLog.WriteError("EntitySync Notify error:{0}", ex);
}
}
private void SetEntityValue(SchemaTable schemaTable, IDataReader reader, AbstractEntity entity)
{
var columns = schemaTable.GetColumnNames();
foreach (var columnName in columns)
{
SchemaColumn fieldAttr;
if (!schemaTable.Columns.TryGetValue(columnName, out fieldAttr))
{
continue;
}
object fieldValue = null;
if (fieldAttr.IsJson)
{
var value = reader[columnName];
if (fieldAttr.ColumnType.IsSubclassOf(typeof(Array)))
{
value = value.ToString().StartsWith("[") ? value : "[" + value + "]";
}
try
{
string tempValue = value.ToNotNullString();
if (!string.IsNullOrEmpty(fieldAttr.JsonDateTimeFormat) &&
tempValue.IndexOf(@"\/Date(") == -1)
{
fieldValue = JsonUtils.DeserializeCustom(tempValue, fieldAttr.ColumnType, fieldAttr.JsonDateTimeFormat);
}
else
{
fieldValue = JsonUtils.Deserialize(tempValue, fieldAttr.ColumnType);
}
}
catch (Exception ex)
{
TraceLog.WriteError("Table:{0} key:{1} column:{2} deserialize json error:{3} to {4}\r\nException:{5}",
schemaTable.Name,
entity.GetKeyCode(),
columnName,
fieldValue,
fieldAttr.ColumnType.FullName,
ex);
}
if (fieldValue is EntityChangeEvent)
{
((EntityChangeEvent)fieldValue).PropertyName = columnName;
}
}
else
{
try
{
fieldValue = entity.ParseValueType(reader[columnName], fieldAttr.ColumnType);
}
catch (Exception ex)
{
TraceLog.WriteError("Table:{0} column:{1} parse value error:\r\n{0}", schemaTable.Name, columnName, ex);
}
}
if (fieldAttr.CanWrite)
{
entity.SetPropertyValue(columnName, fieldValue);
}
else
{
entity.SetFieldValue(columnName, fieldValue);
}
}
}
/// <summary>
/// entity data send to client
/// </summary>
/// <param name="sender"></param>
/// <param name="eventargs"></param>
public static void OnChange(AbstractEntity sender, CacheItemEventArgs eventargs)
{
try
{
if (sender == null ||
(sender as BaseEntity) == null ||
!sender.GetSchema().IsEntitySync)
{
return;
}
string key = sender.GetKeyCode();
if (!_syncPools.ContainsKey(key))
{
_syncPools[key] = true;
_sendQueue.Enqueue(sender as BaseEntity);
singal.Set();
}
}
catch (Exception ex)
{
TraceLog.WriteError("EntitySync Notify error:{0}", ex);
}
}
