Json Work Item Rss Feed

Created Unassigned: enum's [JsonConvert] annotation ignored when enum is Dictionary<> key [24331]

pryankster — Tue, 21 May 2013 23:24:14 GMT

More trouble with enums! The converter is being ignored when the enum is a key in a dictionary. The code snippet below (A LINQPad snippet) should output:
```
{ 'baz': 'baz' }
```
but instead outputs:
```
{ 'SerializeAsBaz': 'baz' }
```

The enum is being correctly converted on the left-hand side, but not the right.

```
void Main()
{
var d = new Dictionary<Foo,object>();
d[Foo.SerializeAsBaz] = Foo.SerializeAsBaz;
newtonSerialize(d).Dump();
}

public static string newtonSerialize(object ob)
{
var j = JsonSerializer.Create();
StringBuilder sb = new StringBuilder(256);
StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture);
using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))
{
jsonWriter.Formatting = Newtonsoft.Json.Formatting.Indented;
jsonWriter.QuoteName = false;
jsonWriter.QuoteChar = '\'';

j.Serialize(jsonWriter, ob);
}
return sw.ToString();
}

// Define other methods and classes here
[JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
enum Foo {
[EnumMember(Value = "foo_bar")] FooBar = 0x01,
Bat = 0x02,
[EnumMember(Value ="baz")] SerializeAsBaz = 0x4,
};
```

Created Unassigned: Assembly Version Update? [24330]

sallgeud — Tue, 21 May 2013 21:24:36 GMT

Unsure if this is an actual issue: The current version (5.0.5) appears to be set as 4.5.0.0 in the assembly. Noticed this when attempting to resolve build warnings with another nuget package.

The following has worked for us, entirely unchanged since 4.5. Not sure if you want it updated.
<bindingRedirect oldVersion="0.0.0.0-4.5.0.0" newVersion="4.5.0.0" />

Created Unassigned: StringEnumConverter ignores [EnumMember] with [Flags] on enum [24329]

pryankster — Tue, 21 May 2013 07:01:56 GMT

When the [Flags] attribute is applied to an enum, and the enum value to serialize is made up of more than one flag value, the StringEnumConverter fails to respect [EnumMemberAttribute].

code below is from a LINQPad snippet:

```
void Main()
{
List<Foo> lfoo = new List<Foo>() { Foo.FooBar, Foo.Bat, Foo.SerializeAsBaz, Foo.Bat | Foo.SerializeAsBaz, Foo.FooBar|Foo.SerializeAsBaz};
List<Bar> lbar = new List<Bar>() { Bar.FooBar, Bar.Bat, Bar.SerializeAsBaz };

lfoo.Dump();
Test("List<Foo> (bitmapped, string mapped with EnumMember)",lfoo);
lbar.Dump();
Test("List<Bar> (not bitmapped, string mapped with EnumMember)", lbar);

}

public static void Test<T>(string name, T ob)
{
var jstr = newtonSerialize(ob);

string.Format("Serialized {0}: {1}", name, jstr).Dump();

var new_list = JsonConvert.DeserializeObject<T>(jstr);
string.Format("Deserialize {0}:", name).Dump();
new_list.Dump();
}

public static string newtonSerialize(object ob)
{
var j = JsonSerializer.Create();
StringBuilder sb = new StringBuilder(256);
StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture);
using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))
{
jsonWriter.Formatting = Newtonsoft.Json.Formatting.Indented;
jsonWriter.QuoteName = false;
jsonWriter.QuoteChar = '\'';

j.Serialize(jsonWriter, ob);
}
return sw.ToString();
}

// Define other methods and classes here
[Flags]
[JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
enum Foo {
[EnumMember(Value = "foo_bar")] FooBar = 0x01,
Bat = 0x02,
[EnumMember(Value ="baz")] SerializeAsBaz = 0x4,
};

[JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
enum Bar {
[EnumMember(Value = "foo_bar")] FooBar,
Bat,
[EnumMember(Value ="baz")] SerializeAsBaz
};

```

Commented Unassigned: Reference loop handling doesn't work, even with reference tracking on [24328]

ekolis — Tue, 21 May 2013 05:58:49 GMT

Sometimes I get nulls in arbitrary places:

http://stackoverflow.com/questions/16472958/json-net-silently-ignores-circular-references-and-sets-arbitrary-links-in-the-ch

And sometimes I just get exceptions. I thought JSON.NET was supposed to support reference loops when I turned reference tracking on?
Comments: ** Comment from web user: ekolis **

Well, I was half mistaken there. It did *serialize* the game state correctly; it simply failed to *deserialize* it correctly. That mistaken data was then placed into the player view. (My code is currently set to test serialization by saving and loading the game before creating the player view.) Still no idea why the simplified object graph is deserializing properly and the full one isn't.

Commented Unassigned: Reference loop handling doesn't work, even with reference tracking on [24328]

ekolis — Tue, 21 May 2013 05:51:43 GMT

Oh, wait, it did serialize it! I was looking at the wrong file. I'm working on a strategy game, and I was looking at the player's view, which had some information taken out for fog of war purposes. The master game state file did have the properly serialized data. I guess the fog of war code removed the information I wanted from the player's view, even though it wasn't supposed to.

Commented Unassigned: Reference loop handling doesn't work, even with reference tracking on [24328]

ekolis — Tue, 21 May 2013 05:48:44 GMT

Is there a limit to how deeply I can nest objects, perhaps? The loop only occurs after I'm already a few levels into the hierarchy.

Commented Unassigned: Reference loop handling doesn't work, even with reference tracking on [24328]

ekolis — Tue, 21 May 2013 05:45:38 GMT

I have no idea what's going on. It works perfectly when I use a simplified version of my object graph, but when I use the actual code I'm working on, it breaks.

Commented Unassigned: Reference loop handling doesn't work, even with reference tracking on [24328]

ekolis — Tue, 21 May 2013 04:50:56 GMT

I assume you mean repro? I'll see what I can do...

Commented Unassigned: Reference loop handling doesn't work, even with reference tracking on [24328]

JamesNK — Tue, 21 May 2013 04:16:24 GMT

I need a simple repo.

Created Unassigned: Reference loop handling doesn't work, even with reference tracking on [24328]

ekolis — Tue, 21 May 2013 00:04:31 GMT

Closed Unassigned: Support Windows Phone 8 is needed [24323]

JamesNK — Mon, 20 May 2013 23:53:32 GMT

It currently only support Window Phone 7.1.

Could you please make it also support Windows Phone 8 ?

The following error comes from NuGet:

Successfully installed 'Newtonsoft.Json 5.0.5'.
Successfully uninstalled 'Newtonsoft.Json 5.0.5'.
Install failed. Rolling back...
Could not install package 'Newtonsoft.Json 5.0.5'. You are trying to install this package into a project that targets 'WindowsPhone,Version=v8.0', but the package does not contain any assembly references that are compatible with that framework. For more information, contact the package author.

Thanks.
Comments: Log a bug with NuGet. There is a WP8 compatible portable class library that it should pick up.

Created Unassigned: Support Windows Phone 8 is needed [24323]

mingchen — Mon, 20 May 2013 04:35:50 GMT

Commented Issue: TypeConverter on Interfaces [24301]

macandy13 — Fri, 17 May 2013 12:38:32 GMT

In the current implementation of Json.NET, TypeConverters on interfaces and abstract classes are not handled properly (in my opinion). If such a converter exists on an interface, the following code fragment in the ConvertUtils.Convert(object initialValue, CultureInfo culture, Type targetType) method will throw an exception:

(lines 410ff)
if (targetType.IsInterface() || targetType.IsGenericTypeDefinition() || targetType.IsAbstract())
throw new ArgumentException("Target type {0} is not a value type or a non-abstract class.".FormatWith(CultureInfo.InvariantCulture, targetType), "targetType");

But in the next lines, the correct handling of the existing type converter takes place. So I would suggest to remove the above lines from the code. This does not break any unit tests and works (at least in my scenario it worked perfectly).

The case where no type converter is placed on an interface/abstract class is handled at the very end of the method.
Comments: ** Comment from web user: macandy13 **

Attached is a file that contains a sample that should cover the three cases where TypeConverter should be used store/restore interfaces, especially in combination with dictionaries.

I also adapted the code of Json.Net (version 5.0r5) to make the sample run. That required two changes, the one described above and another one that actually utilizes an associated TypeConverter to stringify dictionary keys.

It would be great if the two modifications could be part of the Json.NET deliver, since they do not break the unit tests but make TypeConverter handling more consistent (at least from my point of view).

Created Unassigned: [Win2003 & Newtonsoft.Json.dll (.NET2.0version)]Build issue! [24316]

pangxiaoliang — Fri, 17 May 2013 10:57:16 GMT

When build in VS there is a exception occurs which is as following:
Missing compiler required member 'System.Runtime.CompilerServices.ExtensionAttribute..ctor'

Could you please explain what's the reason of this issue? And please help me to resolve this issue~
If you can not resolve this issue please let me know ASAP, Thx a lot :)

Created Unassigned: Serialized Guid not converting in JToken [24314]

kl_mallory — Fri, 17 May 2013 04:53:13 GMT

When serializing a Guid property using the BSONWriter, loading the result in a JObject does not allow me to get the property using the "Value<>" method. The JToken uses the Extensions.cs instead of the same method used by the BsonWriter.

adding this to the Convert method in Extensions.cs

```

else if (token is byte[] && typeof(U)== typeof(Guid))
return (U)(object)(new Guid((byte[])(token as JValue)));

```
solves the problem.

Commented Issue: Data loss when serializing a large decimal [24183]

simon_laing — Thu, 16 May 2013 11:20:06 GMT

Hi,

I am trying to serialize a list of objects, which contains decimals some times. When I serialize it using BSON it usually works. In some cases, in particular when serializing large decimal values, the BSON serializer loses data.

An example:

``` c#
using Newtonsoft.Json;
using Newtonsoft.Json.Bson;
using System;
using System.IO;

namespace NewtonsoftJsonBugReport
{
static class Program
{
class X
{
public X()
{ }

public X(decimal d)
{
this.Data = d;
}

public decimal Data { get; set; }
}

/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
decimal d = 42386543286548654368345865241M;

byte[] output;

Console.WriteLine("Input value {0}", d);

JsonSerializer jsonSerializer = new JsonSerializer();

using (MemoryStream ms = new MemoryStream())
{
using (JsonWriter writer = new BsonWriter(ms))
{
jsonSerializer.Serialize(writer, new X(d));
}

output = ms.ToArray();
}

using (MemoryStream ms = new MemoryStream(output))
{
using (JsonReader reader = new BsonReader(ms))
{
X x = jsonSerializer.Deserialize<X>(reader);

d = x.Data;
}
}

Console.WriteLine("Output value {0}", d);

Console.ReadKey();
}
}
}
```

As you will see, the input is different from the output. This is obviously unwanted, but it also happens silently.

The cause can be found in the BsonBinaryWriter (about line 114)

``` c#
case BsonType.Number:
{
BsonValue value = (BsonValue)t;
_writer.Write(Convert.ToDouble(value.Value, CultureInfo.InvariantCulture));
}
break;
```

All numerics, except Int32 and Int64, are converted to Double, which causes the loss of data.

My suggestion would be:
1. To check if the converted data is the same as the input data. Like this, assuming that we are writing a Decimal:

decimal originalValue = (decimal)value.Value;
double d = Convert.ToDouble(value.Value, CultureInfo.InvariantCulture));
decimal convertedValue = Convert.ToDecimal(d);

``` c#
if (originalValue != convertedValue)
{
throw new Exception("Cannot convert value to a lossless representative.");
}
```

2. To include Decimal, Float and other types in BsonType so the writer can convert to and from the right type.

Looking forward to your reply.
Comments: ** Comment from web user: simon_laing **

Hi James,

There appears to be an issue with deserialising decimals with numbers larger than Math.Abs(long.MinValue).
for example, decimal.MaxValue.

1. ConvertUtils.Int64TryParse() returns ParseResult.Overflow
2. JsonTextReader.ParseNumber() throws because the value is not an integer when trying to parse into a BigInteger.

If ConvertUtils.Int64TryParse() returned ParseResult.Invalid then an attempt would be made to parse the value into a decimal/Double and would succeed.

Decimal.MaxValue parsing works correctly in versions 4.5.4 and 4.5.6

Commented Issue: TypeConverter on Interfaces [24301]

JamesNK — Tue, 14 May 2013 23:50:14 GMT

Could you attach an example of the scenario that you think should work?

Closed Issue: InvalidCastException when deserializing custom IConvertible [24285]

JamesNK — Tue, 14 May 2013 23:22:45 GMT

Since upgrading JSon.NET from 4.5 to 5.0.5 my custom value type (a mathematical `Ratio<T>` class that implements `IConvertible`) no longer deserializes successfully. Instead I get an `InvalidCastException`.

The problem occurs because for example a `Ratio<int>` value is serialized as single number string if the ratio represents a whole number, whereas it is serialised as a fraction (for example 1/2) otherwise. When deserializing an integer source value into a `Ratio<int>` target value, the conversion procedure recognizes both the source value (`Int32` type) and the target value (`Ratio<int>` type) as `IConvertible` and calls `Convert.ChangeType(intValue, typeof(Ratio<int>), culture)`, causing an `InvalidCastException` because the `System.Int32` class doesn't know how to convert to `Ratio<int>` values.

For this reason `Convert.ChangeType` should not be relied on when deserialising values into `IConvertible` types that are non-system types.
Comments: Thanks. Fixed

Commented Issue: InvalidCastException when deserializing custom IConvertible [24285]

ggeurts — Tue, 14 May 2013 12:05:14 GMT

```
namespace JsonConvertible
{
using System;
using System.Globalization;
using System.Runtime.Serialization;
using Newtonsoft.Json;

class Program
{
static void Main(string[] args)
{
var ratio = new Ratio(2, 1);
var json = JsonConvert.SerializeObject(ratio);

// Throws exception in Newtonsoft.Json 5.0.5
var ratio2 = JsonConvert.DeserializeObject<Ratio>(json);
}
}

public struct Ratio: IConvertible, IFormattable, ISerializable
{
private readonly int _numerator;
private readonly int _denominator;

public Ratio(int numerator, int denominator)
{
_numerator = numerator;
_denominator = denominator;
}

#region Properties

public int Numerator
{
get { return _numerator; }
}

public int Denominator
{
get { return _denominator; }
}

public bool IsNan
{
get { return _denominator == 0; }
}

#endregion

#region Serialization operations

public Ratio(SerializationInfo info, StreamingContext context)
{
_numerator = info.GetInt32("n");
_denominator = info.GetInt32("d");
}

public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("n", _numerator);
info.AddValue("d", _denominator);
}

#endregion

#region IConvertible Members

public TypeCode GetTypeCode()
{
return TypeCode.Object;
}

public bool ToBoolean(IFormatProvider provider)
{
return this._numerator == 0;
}

public byte ToByte(IFormatProvider provider)
{
return (byte)(this._numerator / this._denominator);
}

public char ToChar(IFormatProvider provider)
{
return Convert.ToChar(this._numerator / this._denominator);
}

public DateTime ToDateTime(IFormatProvider provider)
{
return Convert.ToDateTime(this._numerator / this._denominator);
}

public decimal ToDecimal(IFormatProvider provider)
{
return (decimal)this._numerator / this._denominator;
}

public double ToDouble(IFormatProvider provider)
{
return this._denominator == 0
? double.NaN
: (double)this._numerator / this._denominator;
}

public short ToInt16(IFormatProvider provider)
{
return (short)(this._numerator / this._denominator);
}

public int ToInt32(IFormatProvider provider)
{
return this._numerator / this._denominator;
}

public long ToInt64(IFormatProvider provider)
{
return this._numerator / this._denominator;
}

public sbyte ToSByte(IFormatProvider provider)
{
return (sbyte)(this._numerator / this._denominator);
}

public float ToSingle(IFormatProvider provider)
{
return this._denominator == 0
? float.NaN
: (float)this._numerator / this._denominator;
}

public string ToString(IFormatProvider provider)
{
return this._denominator == 1
? this._numerator.ToString(provider)
: this._numerator.ToString(provider) + "/" + this._denominator.ToString(provider);
}

public object ToType(Type conversionType, IFormatProvider provider)
{
return Convert.ChangeType(ToDouble(provider), conversionType, provider);
}

public ushort ToUInt16(IFormatProvider provider)
{
return (ushort)(this._numerator / this._denominator);
}

public uint ToUInt32(IFormatProvider provider)
{
return (uint)(this._numerator / this._denominator);
}

public ulong ToUInt64(IFormatProvider provider)
{
return (ulong)(this._numerator / this._denominator);
}

#endregion

#region String operations

public override string ToString()
{
return ToString(CultureInfo.InvariantCulture);
}

public string ToString(string format, IFormatProvider formatProvider)
{
return ToString(CultureInfo.InvariantCulture);
}

public static Ratio Parse(string input)
{
return Parse(input, CultureInfo.InvariantCulture);
}

public static Ratio Parse(string input, IFormatProvider formatProvider)
{
Ratio result;
if (!TryParse(input, formatProvider, out result))
{
throw new FormatException(
string.Format(
CultureInfo.InvariantCulture,
"Text '{0}' is invalid text representation of ratio",
input));
}
return result;
}

public static bool TryParse(string input, out Ratio result)
{
return TryParse(input, CultureInfo.InvariantCulture, out result);
}

public static bool TryParse(string input, IFormatProvider formatProvider, out Ratio result)
{
if (input != null)
{
var fractionIndex = input.IndexOf('/');

int numerator;
if (fractionIndex < 0)
{
if (int.TryParse(input, NumberStyles.Integer, formatProvider, out numerator))
{
result = new Ratio(numerator, 1);
return true;
}
}
else
{
int denominator;
if (int.TryParse(input.Substring(0, fractionIndex), NumberStyles.Integer, formatProvider, out numerator) &&
int.TryParse(input.Substring(fractionIndex + 1), NumberStyles.Integer, formatProvider, out denominator))
{
result = new Ratio(numerator, denominator);
return true;
}
}
}

result = default(Ratio);
return false;
}

#endregion
}

}

```

Commented Issue: InvalidCastException when deserializing custom IConvertible [24285]

ggeurts — Tue, 14 May 2013 10:32:44 GMT

My unit tests pass when using version 4.5.11, but fail under 5.0.5. I will try to get some sample code to illustrate the issue.