How to Deserialize JSON to Dictionary with non-string (e.g. FileInfo) key type

Question

I have this rather simple test and trying to get it working for days now, without success:

using System.Drawing;
using Newtonsoft.Json;

namespace JSON_Trials;

class StackExample {
    public static void Main() {
        Dictionary<FileInfo, Point> dict_write = new() {
            {new("a_file_name.txt"), new(1, 2)},
        };

        var json_write = JsonConvert.SerializeObject(dict_write);
        File.WriteAllText("_dict.json", json_write);

        var json_read = File.ReadAllText("_dict.json");
        var dict_read = JsonConvert.DeserializeObject<Dictionary<FileInfo, Point>>(json_read);
        Console.WriteLine(dict_read.Count);
    }
}

Basically, I'm just trying to round trip the Dictionary.

In this basic form, it creates the following error:

Newtonsoft.Json.JsonSerializationException: 'Could not convert string 'a_file_name.txt' to dictionary key type 'System.IO.FileInfo'. Create a TypeConverter to convert from the string to the key type object. Path '['a_file_name.txt']', line 1, position 19.'

Just for completeness, this is the generated json in the file:

{"a_file_name.txt":"1, 2"}

I have written many TypeConverters, JsonConverters, ContractResolverthingys and such and none of these approaches work. What am I missing here? Is there a way to do this at all? It should be super easy, right? I mean FileInfo has a single string constructor and the json is in the format of a Dictionary anyways. Any hint is much appreciated even if the "solution" might not be straight forward.

Since there are 3 (three!) valid solutions now, some clarification of this particular scenario seems appropriate:

• The Key of the Dictionary is a type of object, that has a 'single string' constructor (in this case, FileInfo(string filename)).
• The type of the Key is not controlled (source code can not be changed, no annotations added).
• The JSON should stay the same (no arrays).
• The Value doesn't really matter here.

P.S.: For all versions, we can just assume the most recent one. atm: .NET 7 & C# 11

Solution

This is the final code I ended up with, thanks @Serg! I also use FullName, as the full name is close enough to a unique identifier for me :-)

using System.ComponentModel;
using System.Drawing;
using System.Globalization;
using Newtonsoft.Json;

namespace JSON_Trials;

class StackExample {
    public static void Main() {
        Dictionary<FileInfo, Point> dict_write = new() {
            {new("a_file_name.txt"), new(1, 2)},
        };

        TypeDescriptor.AddAttributes(typeof(FileInfo), new TypeConverterAttribute(typeof(FileInfoTypeConverter)));

        var json_write = JsonConvert.SerializeObject(dict_write);
        File.WriteAllText("_dict.json", json_write);

        var json_read = File.ReadAllText("_dict.json");
        var dict_read = JsonConvert.DeserializeObject<Dictionary<FileInfo, Point>>(json_read);
        Console.WriteLine(dict_read.Count);
    }
}

internal class FileInfoTypeConverter : TypeConverter {
    public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType) {
        if (sourceType == typeof(string))
            return true;
        return base.CanConvertFrom(context, sourceType);
    }

    public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value) {
        if (value is string str)
            return new FileInfo(str);
        return base.ConvertFrom(context, culture, value);
    }

    public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType) {
        if (value is FileInfo fi)
            return fi.FullName;
        return base.ConvertTo(context, culture, value, destinationType);
    }
}

Answer 1

There are a several causes of such a behaviour.

1. In the JSON the dictionaries may have only strings as a keys. No objects allowed there. So, when you serializing your dictionary, you see the result of FileInfo.ToString as a key. Normally, outside of dictionary, the FileInfo object is not serializable at all and JsonConvert.SerializeObject(new FileInfo("test.txt")); will throw an exception. This may be solved with custom ContractResolver which will force to process dictionary as an array which elements are key-value pairs from a dictionary. More details https://stackoverflow.com/a/25064637/2011071
2. FileInfo is not serializable out-of-the-box, so you need to provide appropriate JsonConverter for this.

Update: if a dictionary-like JSON format is mandatory, I only know the two-stage solution, see at the end of the post

So, the final (simplified) solution may looks like this:

using System.Collections;
using System.Drawing;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;

namespace JSON_Trials;

class StackExample
{
    public static void Main()
    {
        Dictionary<FileInfo, Point> dict_write = new() 
        {
            {new("a_file_name.txt"), new(1, 2)},
        };

        var jsonSerializerSettings = new JsonSerializerSettings
        {
            ContractResolver = new DictionaryAsArrayResolver(),
            Converters = new List<JsonConverter>
            {
                new FileInfoJsonConverter(),
            }
        };

        var json_write = JsonConvert.SerializeObject(dict_write, jsonSerializerSettings);
        File.WriteAllText("_dict.json", json_write);

        var json_read = File.ReadAllText("_dict.json");
        var dict_read = JsonConvert.DeserializeObject<Dictionary<FileInfo, Point>>(json_read, jsonSerializerSettings);
        Console.WriteLine(dict_read.Count);
    }
}

internal class DictionaryAsArrayResolver : DefaultContractResolver
{
    protected override JsonContract CreateContract(Type objectType)
    {
        if (objectType
            .GetInterfaces()
            .Any(i => i == typeof(IDictionary)
                      || (i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IDictionary<,>))))
        {
            return base.CreateArrayContract(objectType);
        }

        return base.CreateContract(objectType);
    }
}

public class FileInfoJsonConverter : JsonConverter
{
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var obj = JToken.FromObject(value.ToString());
        obj.WriteTo(writer);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType != JsonToken.String)
        {
            throw new Exception("Can only read from strings.");
        }
        return new FileInfo((string)reader.Value);
    }

    public override bool CanRead => true;

    public override bool CanConvert(Type objectType) => objectType == typeof(FileInfo);
}

Update: To have JSON in dictionary-style format, the only way I know will be to deserialize into the Dictionary<string, Point first and then convert string key into the FileInfo

var tmp = JsonConvert.DeserializeObject<Dictionary<string, Point>>(json_read);
var dict_read = tmp.ToDictionary(kv => new FileInfo(kv.Key), kv => kv.Value);

In this sample you do not need any additional ContractResolver or JsonConverter at all.

Update 2: the other solution is to assign a TypeConverter to the FileInfo, but it can be done only globally so I can't estimate the possible side effects and can't r recommend is way in a production.

//call once somewhere before deserialization
TypeDescriptor.AddAttributes(typeof(FileInfo), new TypeConverterAttribute(typeof(FileInfoTypeConverter)));


internal class FileInfoTypeConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType)
    {
        if (sourceType == typeof(string))
        {
            return true;
        }

        return base.CanConvertFrom(context, sourceType);
    }

    public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value)
    {
        if (value is string str)
        {
            return new FileInfo(str);
        }
        return base.ConvertFrom(context, culture, value);
    }

    public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType)
    {
        if (value is FileInfo fi)
        {
            return fi.Name;
        }
        return base.ConvertTo(context, culture, value, destinationType);
    }
}