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列类型：

您可以使用typed DataSet。在这种情况下，列类型将是预定义的。
您可以使用this answer中的PreferInt32JsonTextReader到 Overriding Default Primitive Type Handling in Json.Net （Json.NET 10.0.1或更高版本）进行阅读。
< / li>

反序列化后，您可以将列转换为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? 。

您可以派生自己的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 。

OP asks，其性能如何...？

您必须对其进行测试，然后查看https://ericlippert.com/2012/12/17/performance-rant/。

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

Answer 2

我建议您使用此DataTableConverter（Newtonsoft.Json的主DataTableConverter中的Fork）。该转换器有两个好处： 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);
    }
}

更改数字反序列化的默认类型

2 个答案: