如何更改数值反序列化中的默认类型

当我将某些JSON数据反序列化为DataSet时，生成的数据集可能会丢失其列模式。这意味着，当我反序列化某些JSON时，它会用Int64对象而不是Int32填充数据集。我希望它选择Int32。

我知道，Json.NET默认情况下将整数值读取为Int64，因为无法知道该值是Int32还是Int64。

JsonSerializerSettings settings = new JsonSerializerSettings()
{
Converters = { new PrimitiveJsonConverter() },
};
DataSet myDataSet = JsonConvert.DeserializeObject<DataSet>(jsonString, settings);

因此，我创建了自定义JsonConverter，以覆盖默认功能。

using DevExpress.XtraPrinting.Native.WebClientUIControl;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization.Formatters;
using System.Text;
using System.Threading.Tasks;
using JsonConverter = Newtonsoft.Json.JsonConverter;
namespace CashlessAdmin.API.Handler
{
public sealed class PrimitiveJsonConverter : JsonConverter
{
readonly JsonSerializer defaultSerializer = new JsonSerializer();
public override bool CanConvert(Type objectType)
{
return objectType.IsIntegerTypes();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
switch (reader.TokenType)
{
case JsonToken.Integer:
if(Convert.ToInt64(reader.Value) < System.Int32.MaxValue)
{
return Convert.ToInt32(reader.Value);
}
return reader.Value;
case JsonToken.Float: // Accepts numbers like 4.00
case JsonToken.Null:
return defaultSerializer.Deserialize(reader, objectType);
default:
throw new JsonSerializationException(string.Format("Token "{0}" of type {1} was not a JSON integer", reader.Value, reader.TokenType));
}
}
public override bool CanWrite { get { return false; } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
public static class JsonExtensions
{
public static bool IsIntegerTypes(this Type type)
{
type = Nullable.GetUnderlyingType(type) ?? type;
if (type == typeof(long)
|| type == typeof(ulong)
|| type == typeof(int)
|| type == typeof(uint)
|| type == typeof(short)
|| type == typeof(ushort)
|| type == typeof(byte)
|| type == typeof(sbyte)
|| type == typeof(System.Numerics.BigInteger))
return true;
return false;
}
}
}

但结果将与之前的情况相同。

代码不起作用的原因是，在最初推断列类型时，DataTableConverter不会尝试反序列化列遇到的第一个值。相反，它只需使用JsonReader.Read()读取，然后在DataTableConverter.GetColumnDataType()中将列类型设置为观察到的令牌类型。您的方法PrimitiveJsonConverter.Read()此时没有被调用。而且，由于JsonReader.Read()被设计为返回整数值的long而不是int，因此数据表列类型最终为long。

您有几个选项可以覆盖Newtonsoft的默认行为并获得Int32列类型：

您可以使用类型化的DataSet。在这种情况下，列类型将是预定义的。
您可以使用PreferInt32JsonTextReader从Json.Net(Json.NET10.0.1或更高版本)中的覆盖默认基元类型处理的答案中读取。

可以在反序列化后将列转换为Int32。首先，介绍以下扩展方法：

public static class DataTableExtensions
{
public static DataTable RemapInt64ColumnsToInt32(this DataTable table)
{
if (table == null)
throw new ArgumentNullException();
for (int iCol = 0; iCol < table.Columns.Count; iCol++)
{
var col = table.Columns[iCol];
if (col.DataType == typeof(Int64)
&& table.AsEnumerable().Where(r => !r.IsNull(col)).Select(r => (Int64)r[col]).All(i => i >= int.MinValue && i <= int.MaxValue))
{
ReplaceColumn(table, col, typeof(Int32), (o, t) => o == null ? null : Convert.ChangeType(o, t, NumberFormatInfo.InvariantInfo));
}
}
return table;
}
private static DataColumn ReplaceColumn(DataTable table, DataColumn column, Type newColumnType, Func<object, Type, object> map)
{
var newValues = table.AsEnumerable()
.Select(r => r.IsNull(column) ? (object)DBNull.Value : map(r[column], newColumnType))
.ToList();
var ordinal = column.Ordinal;
var name = column.ColumnName;
var @namespace = column.Namespace;
var newColumn = new DataColumn(name, newColumnType);
newColumn.Namespace = @namespace;
table.Columns.Remove(column);
table.Columns.Add(newColumn);
newColumn.SetOrdinal(ordinal);
for (int i = 0; i < table.Rows.Count; i++)
if (!(newValues[i] is DBNull))
table.Rows[i][newColumn] = newValues[i];
return newColumn;
}    
}

然后做：

var myDataSet = JsonConvert.DeserializeObject<DataSet>(json);
myDataSet.Tables.Cast<DataTable>().Aggregate((object)null, (o, dt) => dt.RemapInt64ColumnsToInt32());

相关：如何更改DataTable中DataColumn的DataType。

您可以派生自己版本的DataTableConverter，并修改DataTableConverter.GetColumnDataType()的逻辑以返回JsonToken.Integer令牌的typeof(Int32)。

有关所涉及内容的示例，请参阅对缺少第一列的数据表进行反序列化的答案。

由于根对象是DataSet，您还需要派生自己版本的DataSetConverter，并使其使用自定义的DataTableConverter，如下面对的回答所示，在反序列化Custom Class上的DataTable属性后，DateTime列类型变为String类型。

OP问道，它的性能如何

你必须测试一下，看看，看看https://ericlippert.com/2012/12/17/performance-rant/.

也就是说，通常，对于巨大的数据集，您希望避免在最终反序列化之前以某种中间表示(例如JToken层次结构或单个大string)将整个数据集加载到内存中。选项#1、#2和#4避免这样做。#3确实将一部分数据加载到中间表示中；一些但不是所有的CCD_ 22列最终被加载然后被替换。因此，性能可能还可以，但可能不可以——您需要检查一下。

我建议您使用这个DataTableConverter(来自Newtonsoft.Json的主DataTableConverterFork)。这种转换器有两个好处：1.列的DataType存储在序列化的json中，反序列化后不更改。2.序列化json的大小减少了，性能得到了优化，因为ColumnName不为每一行存储。

public class DataTableConverter : JsonConverter
{
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DataTable table = (DataTable)value;
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName("Columns");
serializer.Serialize(writer, GetColumnDataTypes(table));
writer.WritePropertyName("Rows");
writer.WriteStartArray();
foreach (DataRow row in table.Rows)
{
serializer.Serialize(writer, row.ItemArray);
}
writer.WriteEndArray();
writer.WriteEndObject();
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return null;
}
DataTable dataTable = existingValue as DataTable;
if (dataTable == null)
{
// handle typed datasets
dataTable = (objectType == typeof(DataTable))
? new DataTable()
: (DataTable)Activator.CreateInstance(objectType);
}
// DataTable is inside a DataSet
// populate the name from the property name
if (reader.TokenType == JsonToken.PropertyName)
{
dataTable.TableName = (string)reader.Value;
reader.Read();
if (reader.TokenType == JsonToken.Null)
{
return dataTable;
}
}
if (reader.TokenType == JsonToken.StartObject)
{
reader.Read();
if (reader.TokenType == JsonToken.PropertyName && (string)reader.Value == "Columns")
{
reader.Read();
Dictionary<string, string> columnTypes = new Dictionary<string, string>();
columnTypes = serializer.Deserialize<Dictionary<string, string>>(reader);
foreach (KeyValuePair<string, string> column in columnTypes)
{
dataTable.Columns.Add(column.Key, Type.GetType(column.Value));
}
}
reader.Read();
reader.Read();
}
if (reader.TokenType != JsonToken.StartArray)
{
throw new JsonSerializationException($"Unexpected JSON token when reading DataTable. Expected StartArray, got {reader.TokenType}.");
}
reader.Read();
while (reader.TokenType != JsonToken.EndArray)
{
DataRow dr = dataTable.NewRow();
dr.ItemArray = serializer.Deserialize<System.Object[]>(reader);
dataTable.Rows.Add(dr);
reader.Read();
}
reader.Read();
return dataTable;
}
private static Dictionary<string, string> GetColumnDataTypes(DataTable dt)
{
Dictionary<string, string> columnTypes = new Dictionary<string, string>();
foreach (DataColumn column in dt.Columns)
columnTypes.Add(column.ColumnName, column.DataType.FullName);
return columnTypes;
}
/// <summary>
/// Determines whether this instance can convert the specified value type.
/// </summary>
/// <param name="valueType">Type of the value.</param>
/// <returns>
///     <c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.
/// </returns>
public override bool CanConvert(Type valueType)
{
return typeof(DataTable).IsAssignableFrom(valueType);
}
}

相关内容

最新更新

热门标签：