JSON.NET将System.Object属性的类型自动更改为System.String

Question

I have a class named Arg . The Property ArgValue is of the Type System.Object .

public class Arg
{
    public string ArgName { get; set; }
    public object ArgValue { get; set; }
}

If I want to deserialize a JSON-string like this:

string json = @"{""ArgName"":""arg"",""ArgValue"":""/something/more/than/a/string/""}";

var jsonSerializerSettings = new JsonSerializerSettings() { };

Arg arg = JsonConvert.DeserializeObject<Arg>(json, jsonSerializerSettings);

I get the Arg object with its values like this:

• ArgName is of type string -> arg
• ArgValue is of type object {string} -> /something/more/than/a/string/

I do not want that JSON.NET is converting it into System.String . If the property is of type System.Object it should not convert it into a string.

It would be better it leaves it untouched and the value would be of type: JToken (or JValue ).

Is there a JsonSerializerSettings option to configure this behaviour?

Additional information:

The string value in the property ArgValue is "more than a string" and I need to convert it later by myself. JsonConverter cannot be used here, because i do not know the concrete type of the object at this point. later i know and need to use JToken.ToObject<MySpecialType>() . (Than it gets correctly converted by a JsonConverter ).

Answer 1

As I stated in the comment, the json string you want to deserialize will be deserialized into an object of a class with two properties, both of type string. This is because when you specify "ArgName" : "arg" the two quotes between arg mark a value of type string. This is also the case of ArgValue which is serialized also as a string.

By doing this line of code:

Arg arg = JsonConvert.DeserializeObject<Arg>(json, jsonSerializerSettings);

You receive an object ( arg ) of type Arg which is exactly as a classical object of type Arg . It is the equivalent of doing:

Arg arg = new Arg{ ArgName = "arg", ArgValue = "/something/more/than/a/string/" };

The string assignation of property ArgValue which expects an object is the same in the case of deserialize, it is no conversion (or better said cast ) involved, it is only boxing .

Answer 2

For later conversion you can use

Generics

public class Arg<T>
{
    public string ArgName { get; set; }
    public T ArgValue { get; set; }
}

then you can pass target type as follows:

JsonConvert.DeserializeObject<Arg<Qualifiedname>>(somestring);

or

public Arg<T> Deserialize<T>(string somestring){
  return JsonConvert.DeserializeObject<Arg<T>>(somestring);
}

Leave it as JToken

public class Arg
{
    public string ArgName { get; set; }
    public JToken ArgValue { get; set; }
}

Deserialize it later with JsonConvert

public class Arg
{
    public string ArgName { get; set; }
    public string ArgValue { get; set; }
}

or simply pass it whole as string until you know what type is going to be parsed..