C# 如何正确覆盖对象[]的ReadJson方法？

我正在尝试为对象[]创建一个json转换器来定义我想要的类型（例如int32而不是int64）

这是我到目前为止得到的：

对象：

[JsonObject]
public class tipo
{
    public string teste { get; set; }

    [JsonConverter(typeof(TestConverter))]
    public object[] metodos { get; set; }
}

主要问题：

    string call = JsonConvert.SerializeObject(new tipo { teste="nota",
    metodos = new object[] { 10, (decimal)10.5, "Teste123" } });

    tipo t = JsonConvert.DeserializeObject<tipo>(call);

string call=JsonConvert.SerializeObject（新的tipo{teste=“nota”，
metodos=新对象[]{10，（十进制）10.5，“Teste123”}）；
tipo t=JsonConvert.DeserializeObject（调用）；

JsonConverter：

namespace Newtonsoft.Json
{
public class TestConverter : JsonConverter
{
    #region Overrides of JsonConverter
    
    public override bool CanWrite { get { return false; } }
    
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        List<object> resultado = new List<object>();

        string propertyName = reader.Value as string;
        while (reader.Read())
        {
            object value = null;

            switch (reader.TokenType)
            {
                case JsonToken.Integer:
                    value = Convert.ToInt32(reader.Value);
                    resultado.Add(value);
                    break;
                case JsonToken.Float:
                    value = Convert.ToDecimal(reader.Value);
                    resultado.Add(value);
                    break;
                case JsonToken.String:
                    value = Convert.ToString(reader.Value);
                    resultado.Add(value);
                    break;
                case JsonToken.Boolean:
                    value = Convert.ToBoolean(reader.Value);
                    resultado.Add(value);
                    break;
                case JsonToken.Null:
                    value = null;
                    resultado.Add(value);
                    break;
                case JsonToken.Date:
                    value = Convert.ToDateTime(reader.Value);
                    resultado.Add(value);
                    break;
                case JsonToken.Bytes:
                    value = Convert.ToByte(reader.Value);
                    resultado.Add(value);
                    break;
                default:
                    Console.WriteLine("Default case");
                    Console.WriteLine(reader.TokenType.ToString());
                    break;
            }
        }

        return resultado.ToArray();
    }
    
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(object[]);
    }

    #endregion
    }
}

namespace Newtonsoft.Json
{
公共类TestConverter:JsonConverter
{
#JsonConverter的区域覆盖
公共重写bool可以写入{get{return false；}}
公共重写void WriteJson（JsonWriter编写器、对象值、JsonSerializer序列化器）
{
抛出新的NotImplementedException（）；
}
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{
List resultado=新列表（）；
string propertyName=reader.Value作为字符串；
while（reader.Read（））
{
对象值=空；
开关（reader.TokenType）
{
案例JsonToken.Integer：
value=Convert.ToInt32（reader.value）；
结果增加（价值）；
打破
case JsonToken.Float：
value=Convert.ToDecimal（reader.value）；
结果增加（价值）；
打破
case JsonToken.String：
value=Convert.ToString（reader.value）；
结果增加（价值）；
打破
案例JsonToken.Boolean：
value=Convert.ToBoolean（reader.value）；
结果增加（价值）；
打破
案例JsonToken.Null：
值=空；
结果增加（价值）；
打破
案例JsonToken。日期：
value=Convert.ToDateTime（reader.value）；
结果增加（价值）；
打破
案例JsonToken.Bytes：
value=Convert.ToByte（reader.value）；
结果增加（价值）；
打破
违约：
Console.WriteLine（“默认情况”）；
Console.WriteLine（reader.TokenType.ToString（））；
打破
}
}
返回resultado.ToArray（）；
}
公共覆盖布尔CanConvert（类型objectType）
{
返回objectType==typeof（object[]）；
}
#端区
}
}

我检查了输出，一切正常，但在反序列化过程中返回以下错误：

Newtonsoft.Json.dll中发生类型为“Newtonsoft.Json.JsonSerializationException”的未处理异常

其他信息：反序列化对象时意外结束。路径“”，第1行，位置47

你知道怎么解决这个问题吗

---

谢谢

解决了这个问题，现在我有了一个通用的格式转换器：

public class TestConverter : JsonConverter
{
    #region Overrides of JsonConverter

    public override bool CanWrite { get { return false; } }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        object value = new object();     

        if (reader.TokenType != JsonToken.Null)
        {
            if (reader.TokenType == JsonToken.StartArray)
            {
                JToken token = JToken.Load(reader);

                List<object> resultado = new List<object>();

                foreach (var Value in token)
                {
                    switch (Value.Type)
                    {
                        case JTokenType.Integer:
                            value = Convert.ToInt32(Value);
                            resultado.Add(value);
                            break;
                        case JTokenType.Float:
                            value = Convert.ToDecimal(Value);
                            resultado.Add(value);
                            break;
                        case JTokenType.String:
                            value = Convert.ToString(Value);
                            resultado.Add(value);
                            break;
                        case JTokenType.Boolean:
                            value = Convert.ToBoolean(Value);
                            resultado.Add(value);
                            break;
                        case JTokenType.Null:
                            value = null;
                            resultado.Add(value);
                            break;
                        case JTokenType.Date:
                            value = Convert.ToDateTime(Value);
                            resultado.Add(value);
                            break;
                        case JTokenType.Bytes:
                            value = Convert.ToByte(Value);
                            resultado.Add(value);
                            break;
                        default:
                            Console.WriteLine("Default case");
                            Console.WriteLine(reader.TokenType.ToString());
                            break;
                    }
                }
                value = resultado.ToArray();
            }
            else
            {
                JValue jValue = new JValue(reader.Value);
                switch (reader.TokenType)
                {
                    case JsonToken.Integer:
                        value = Convert.ToInt32(reader.Value);
                        break;
                    case JsonToken.Float:
                        value = Convert.ToDecimal(reader.Value);
                        break;
                    case JsonToken.String:
                        value = Convert.ToString(reader.Value);
                        break;
                    case JsonToken.Boolean:
                        value = Convert.ToBoolean(reader.Value);
                        break;
                    case JsonToken.Null:
                        value = null;
                        break;
                    case JsonToken.Date:
                        value = Convert.ToDateTime(reader.Value);
                        break;
                    case JsonToken.Bytes:
                        value = Convert.ToByte(reader.Value);
                        break;
                    default:
                        Console.WriteLine("Default case");
                        Console.WriteLine(reader.TokenType.ToString());
                        break;
                }
            }
        }
        return value;
    }

    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(object);
    }

    #endregion
}

公共类TestConverter:JsonConverter
{
#JsonConverter的区域覆盖
公共重写bool可以写入{get{return false；}}
公共重写void WriteJson（JsonWriter编写器、对象值、JsonSerializer序列化器）
{
抛出新的NotImplementedException（）；
}
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{
对象值=新对象（）；
if（reader.TokenType！=JsonToken.Null）
{
if（reader.TokenType==JsonToken.StartArray）
{
JToken令牌=JToken.Load（读卡器）；
List resultado=新列表（）；
foreach（令牌中的var值）
{
开关（值.类型）
{
案例JTokenType.Integer：
值=转换为32（值）；
结果增加（价值）；
打破
案例JTokenType.Float：
值=转换为特定值（值）；
结果增加（价值）；
打破
案例JTokenType.String：
value=Convert.ToString（值）；
结果增加（价值）；
打破
案例JTokenType.Boolean：
value=Convert.ToBoolean（值）；
结果增加（价值）；
打破
案例JTokenType.Null：
值=空；
结果增加（价值）；
打破
案例JTokenType.日期：
值=Convert.ToDateTime（值）；
结果增加（价值）；
打破
案例JTokenType.Bytes：
值=转换为字节（值）；
结果增加（价值）；
打破
违约：
Console.WriteLine（“默认情况”）；
Console.WriteLine（reader.TokenType.ToString（））；
打破
}
}
value=resultado.ToArray（）；
}
其他的
{
JValue JValue=新的JValue（reader.Value）；
开关（reader.TokenType）
{
案例JsonToken.Integer：
value=Convert.ToInt32（reader.value）；
打破
case JsonToken.Float：
值=C