/// <summary>
/// 序列化行数据
/// </summary>
/// <param name="p_dataRow"></param>
/// <param name="p_writer"></param>
void SerializeJsonRow(Row p_dataRow, Utf8JsonWriter p_writer)
{
p_writer.WriteStartArray();
foreach (var cell in p_dataRow.Cells)
{
if (cell.IsChanged)
{
// 值变化时传递两值数组 [原始值,当前值]
p_writer.WriteStartArray();
JsonRpcSerializer.Serialize(cell.OriginalVal, p_writer);
JsonRpcSerializer.Serialize(cell.Val, p_writer);
p_writer.WriteEndArray();
}
else
{
JsonRpcSerializer.Serialize(cell.Val, p_writer);
}
}
// 行状态，多出的列
if (p_dataRow.IsAdded)
{
p_writer.WriteStringValue("Added");
}
else if (p_dataRow.IsChanged)
{
p_writer.WriteStringValue("Modified");
}
p_writer.WriteEndArray();
}
void IRpcJson.ReadRpcJson(ref Utf8JsonReader p_reader)
{
p_reader.Read();
MethodName = p_reader.GetString();
// 参数外层 [
p_reader.Read();
Params = new List <object>();
while (p_reader.Read())
{
// 参数外层 ]
if (p_reader.TokenType == JsonTokenType.EndArray)
{
break;
}
Params.Add(JsonRpcSerializer.Deserialize(ref p_reader));
}
p_reader.Read();
Title = p_reader.GetString();
p_reader.Read();
Content = p_reader.GetString();
// 最外层 ]
p_reader.Read();
}
/// <summary>
/// 按照系统规则反序列化json串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="p_content"></param>
/// <returns></returns>
public static T Deserialize <T>(string p_content)
{
Throw.IfNullOrEmpty(p_content);
Utf8JsonReader reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(p_content));
reader.Read();
return(JsonRpcSerializer.Deserialize <T>(ref reader));
}
/// <summary>
/// 按照系统规则序列化对象
/// </summary>
/// <param name="p_object"></param>
/// <returns></returns>
public static string Serialize(object p_object)
{
Throw.IfNull(p_object);
using (var stream = new MemoryStream())
{
using (var writer = new Utf8JsonWriter(stream, JsonOptions.UnsafeWriter))
{
JsonRpcSerializer.Serialize(p_object, writer);
}
return(Encoding.UTF8.GetString(stream.ToArray()));
}
}
void IRpcJson.WriteRpcJson(Utf8JsonWriter p_writer)
{
//[
// "#dict",
// ["key1", "类型", "val1"], // 简单类型System.XXX
// ["key2", "Int64", 11],
// ["key3", "Byte[]", "CgwOEA=="],
// ["key4", "", ["#row",...]] // 复杂类型空即可
//]
p_writer.WriteStartArray();
p_writer.WriteStringValue("#dict");
foreach (var item in this)
{
p_writer.WriteStartArray();
p_writer.WriteStringValue(item.Key);
if (item.Value == null)
{
// null按string
p_writer.WriteStringValue("String");
p_writer.WriteNullValue();
}
else
{
var tp = item.Value.GetType();
if (tp.FullName == "System." + tp.Name)
{
// 简单类型
p_writer.WriteStringValue(tp.Name);
}
else if (tp.IsGenericType && tp.GetGenericTypeDefinition() == typeof(Nullable <>))
{
// 可空值类型
p_writer.WriteStringValue(tp.GetGenericArguments()[0].Name + "?");
}
else
{
// 复杂类型空即可
p_writer.WriteStringValue("");
}
JsonRpcSerializer.Serialize(item.Value, p_writer);
}
p_writer.WriteEndArray();
}
p_writer.WriteEndArray();
}
void IRpcJson.WriteRpcJson(Utf8JsonWriter p_writer)
{
p_writer.WriteStartArray();
p_writer.WriteStringValue("#row");
// 行状态
if (IsAdded)
{
p_writer.WriteStringValue("Added");
}
else if (IsChanged)
{
p_writer.WriteStringValue("Modified");
}
p_writer.WriteStartObject();
foreach (var cell in _cells)
{
p_writer.WritePropertyName(cell.ID);
if (cell.IsChanged)
{
// 值变化时传递完整信息 ["类型", "当前值", "原始值"]
p_writer.WriteStartArray();
p_writer.WriteStringValue(Table.GetColTypeAlias(cell.Type));
JsonRpcSerializer.Serialize(cell.Val, p_writer);
JsonRpcSerializer.Serialize(cell.OriginalVal, p_writer);
p_writer.WriteEndArray();
}
else if (cell.Type == typeof(string))
{
// string类型，值无变化
p_writer.WriteStringValue((string)cell.Val);
}
else
{
// 非string类型，值无变化 ["类型", "当前值"]
p_writer.WriteStartArray();
p_writer.WriteStringValue(Table.GetColTypeAlias(cell.Type));
JsonRpcSerializer.Serialize(cell.Val, p_writer);
p_writer.WriteEndArray();
}
}
p_writer.WriteEndObject();
p_writer.WriteEndArray();
}
void IRpcJson.WriteRpcJson(Utf8JsonWriter p_writer)
{
p_writer.WriteStartArray();
p_writer.WriteStringValue("#msg");
p_writer.WriteStringValue(MethodName);
// 参数
p_writer.WriteStartArray();
if (Params != null && Params.Count > 0)
{
foreach (var par in Params)
{
JsonRpcSerializer.Serialize(par, p_writer);
}
}
p_writer.WriteEndArray();
p_writer.WriteStringValue(Title);
p_writer.WriteStringValue(Content);
p_writer.WriteEndArray();
}
void IRpcJson.ReadRpcJson(ref Utf8JsonReader p_reader)
{
//[
// "#dict",
// ["key1", "类型", "val1"], // 简单类型System.XXX
// ["key2", "Int64", 11],
// ["key3", "Byte[]", "CgwOEA=="],
// ["key4", "", ["#row",...]] // 复杂类型空即可
//]
// 项起始 [
while (p_reader.Read())
{
// 外层末尾 ]
if (p_reader.TokenType == JsonTokenType.EndArray)
{
break;
}
// 项
p_reader.Read();
string key = p_reader.GetString();
p_reader.Read();
string tpName = p_reader.GetString();
p_reader.Read();
if (tpName == string.Empty)
{
try
{
this[key] = JsonRpcSerializer.Deserialize(ref p_reader);
}
catch (Exception exception)
{
throw new Exception("反序列化Dict时异常: " + exception.Message);
}
}
else
{
Type tp;
if (tpName.EndsWith("?"))
{
tp = Type.GetType("System." + tpName.TrimEnd('?'), true, false);
tp = typeof(Nullable <>).MakeGenericType(tp);
}
else
{
tp = Type.GetType("System." + tpName, true, false);
}
try
{
this[key] = JsonRpcSerializer.Deserialize(ref p_reader, tp);
}
catch (Exception exception)
{
throw new Exception("反序列化Dict时异常: " + exception.Message);
}
}
// 项末尾 ]
p_reader.Read();
}
}
/// <summary>
/// 反序列化读取Rpc Json数据
/// </summary>
void IRpcJson.ReadRpcJson(ref Utf8JsonReader p_reader)
{
// Entity类型
Type tpEntity = null;
if (GetType().IsGenericType)
{
tpEntity = GetType().GetGenericArguments()[0];
}
// cols外层 [
p_reader.Read();
// 列[
while (p_reader.Read())
{
// cols外层 ]
if (p_reader.TokenType == JsonTokenType.EndArray)
{
break;
}
int index = 0;
string colName = null;
Type colType = null;
// 列 [
while (p_reader.Read())
{
// 列 ]
if (p_reader.TokenType == JsonTokenType.EndArray)
{
break;
}
if (index == 0)
{
colName = p_reader.GetString();
}
else
{
colType = GetColType(p_reader.GetString());
if (colType == typeof(byte) && tpEntity != null)
{
// Entity 时根据属性类型将 byte 自动转为 enum 类型
var prop = tpEntity.GetProperty(colName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.IgnoreCase);
if (prop != null)
{
colType = prop.PropertyType;
}
}
}
index++;
}
_columns.Add(new Column(colName, colType));
}
// rows外层 [
p_reader.Read();
int colCnt = _columns.Count;
// [
while (p_reader.Read())
{
// rows外层 ]
if (p_reader.TokenType == JsonTokenType.EndArray)
{
break;
}
int index = 0;
Row row = AddRow();
row.IsAdded = false;
// 行 [
while (p_reader.Read())
{
// 行 ]
if (p_reader.TokenType == JsonTokenType.EndArray)
{
break;
}
if (index < colCnt)
{
// 值变化时两值 [原始值,当前值]
if (p_reader.TokenType == JsonTokenType.StartArray)
{
// 两值 [
p_reader.Read();
row.Cells[index].OriginalVal = JsonRpcSerializer.Deserialize(ref p_reader, _columns[index].Type);
p_reader.Read();
row.Cells[index].SetVal(JsonRpcSerializer.Deserialize(ref p_reader, _columns[index].Type));
// 两值 ]
p_reader.Read();
}
else
{
// 不会引起连续IsChanged改变
row.Cells[index].InitVal(JsonRpcSerializer.Deserialize(ref p_reader, _columns[index].Type));
}
}
else
{
// 超出的列值为行状态
string state = p_reader.GetString();
if (state == "Added")
{
row.IsAdded = true;
}
else if (state == "Modified")
{
row.IsChanged = true;
}
}
index++;
}
}
// 最外层 ]
p_reader.Read();
}
void IRpcJson.ReadRpcJson(ref Utf8JsonReader p_reader)
{
try
{
// 可能为状态或 {
p_reader.Read();
// 状态
if (p_reader.TokenType == JsonTokenType.String)
{
string state = p_reader.GetString();
if (state == "Added")
{
IsAdded = true;
}
else if (state == "Modified")
{
IsChanged = true;
}
// {
p_reader.Read();
}
bool isEntity = GetType().IsSubclassOf(typeof(Entity));
while (p_reader.Read() && p_reader.TokenType == JsonTokenType.PropertyName)
{
string id = p_reader.GetString();
p_reader.Read();
if (p_reader.TokenType == JsonTokenType.StartArray)
{
// 数组内容： ["类型", "当前值", "原始值"] 或 ["类型", "当前值"]
// 类型
p_reader.Read();
Type type = Table.GetColType(p_reader.GetString());
if (type == typeof(byte) && isEntity)
{
// Entity 时根据属性类型将 byte 自动转为 enum 类型
var prop = GetType().GetProperty(id, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.IgnoreCase);
if (prop != null)
{
type = prop.PropertyType;
}
}
// 当前值
p_reader.Read();
object val = JsonRpcSerializer.Deserialize(ref p_reader, type);
p_reader.Read();
if (p_reader.TokenType == JsonTokenType.EndArray)
{
// 非string类型，值无变化 ["类型", "当前值"]
new Cell(this, id, type, val);
}
else
{
// 值变化时传递完整信息 ["类型", "当前值", "原始值"]
new Cell(this, id, type, JsonRpcSerializer.Deserialize(ref p_reader, type)).SetVal(val);
// ]
p_reader.Read();
}
}
else
{
// string类型，值无变化
new Cell(this, id, typeof(string), JsonRpcSerializer.Deserialize(ref p_reader));
}
}
// 最外层 ]
p_reader.Read();
AttachHook();
}
catch (Exception ex)
{
throw new Exception($"反序列化Row时异常: {ex.Message}");
}
}
