如何在数字反序列化中更改默认类型

Question

当我将一些 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;
        }
    }
}

但是结果会和之前的情况一样。

Answer 1

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

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

1. 您可以使用typed DataSet。在这种情况下，列类型将被预定义。

2. 您可以使用PreferInt32JsonTextReader 从this answer 读取到Overriding Default Primitive Type Handling in Json.Net（Json.NET 10.0.1 或更高版本）。

3. 您可以在反序列化后将列转换为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());
   

   相关：How To Change DataType of a DataColumn in a DataTable?。

4. 您可以分叉您自己的DataTableConverter 版本并修改DataTableConverter.GetColumnDataType() 的逻辑以返回typeof(Int32) 以获得JsonToken.Integer 令牌。

   有关所涉及内容的示例，请参阅this answer 至 deserialize a datatable with a missing first column。

   由于您的根对象是DataSet，您还需要派生您自己的DataSetConverter 版本并使其使用您自定义的DataTableConverter，如this answer 到DateTime column type becomes String type after deserializing DataTable property on Custom Class 中所示/em>。

OP asks，它的性能怎么样...？

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

话虽如此，一般而言，对于庞大的数据集，您希望避免在最终反序列化之前以某种中间表示（例如JToken 层次结构或单个大型string）将整个数据集加载到内存中。选项#1、#2 和#4 避免这样做。 #3 确实将部分数据加载到中间表示中；一些但不是全部DataTable 列最终被加载然后被替换。因此性能可能还可以，但也可能不行——您需要检查一下。

Answer 2

我建议你使用这个 DataTableConverter (Fork from main DataTableConverter of Newtonsoft.Json)。 这个转换器有两个好处： 1. Column的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);
    }
}