Using Newtonsoft.Json, how can I use a SerializationBinder and CustomResolver together to deserialize abstract/interface types?

This is very close to working. The problem is that you have made your IWidget derivative interfaces empty. Since the SerializationBinder is binding the $type codes in the JSON to interfaces instead of concrete types, the contract resolver is going to look at the properties on those interfaces to determine what can be deserialized. (The contract resolver's main responsibility is to map properties in the JSON to their respective properties in the class structure. It assigns a "contract" to each type, which governs how that type is handled during de/serialization: how it is created, whether to apply a JsonConverter to it, and so forth.)

IAssembly doesn't have a Parts list on it, so that's as far as the deserialization gets. Also, the Name property on IWidget does not have a setter, so the name of the root assembly object doesn't get populated either. The NRE is being thrown in the ToString() method in the demo code which is trying to dump out the null Parts list without an appropriate null check (that one's on me). Anyway, if you add the public properties from the concrete Widget types to their respective interfaces, then it works. So:

public interface IWidget
{
    string Name { get; set; }
    string ToString(string indent = "");
}

public interface IAssembly : IWidget 
{
    List<IWidget> Parts { get; set; }
}

public interface IBolt : IWidget 
{
    int HeadSize { get; set; }
    int Length { get; set; }
}

public interface IWasher : IWidget 
{
    public int Thickness { get; set; }
}

public interface INut : IWidget 
{
    public int Size { get; set; }
}

Here's the working Fiddle: https://dotnetfiddle.net/oJ54VD

Brian's answer is wonderful and helped me understand the cause of my problems and how to resolve them. Here's my recipe that I've destilled from the things I've learned.

A noteable difference to the code in the question above or Brian's solution is that here the type alias is associated with two types. Brian's bug fix above was to include the members that needed to be populated in the type that was used by the contract resolver (see below), the service interface type. But these members may not be part of the service interface (which I may not have control over); they may just include some extra data that my class needs internally that need to be (de)serialized.

This is (as always with recipes) just a suggestion based on my specific requirements.

Goal:

• Implement a JSON serialization framework that is bulletproof in the sense that the $type alias in the JSON file is only loosely coupled ("bound") to the actual classes defined in code. This will help us to maintain backwards compatibility between the current code base and JSON files created with an older version.
• Include an IOC ("Inversion Of Control") container for creating the required instances, allowing us to exchange the actual components we want to use for specific services, e.g. for testing with mock classes.

Requirements:

A mechanism to translate/convert the type information throughout the (de)serialization process, specifically:

1. During serialization, determine how the type alias of a specific instance is stored in the $type properties of the JSON file.
2. During deserialization, use the type alias to determine which classes to build.
3. During deserialization, determine how the instances' members are to be populated.

Components:

The following components are going to be used, see this fiddle for a working example.

public class MockIoc
{
    public Dictionary<Type, Type> ServiceToComponentMapping { get; }

    public MockIoc()
    {
        ServiceToComponentMapping = new Dictionary<Type, Type>
        {
            { typeof( IAssembly), typeof(Assembly)   },
            { typeof( IBolt)    , typeof(Bolt)       },
            { typeof( IWasher)  , typeof(Washer)     },
            { typeof( INut)     , typeof(Nut)        },
        };
    }

    public object Resolve(Type serviceType)
    {
        var componentType = ServiceToComponentMapping[serviceType];
        var instance = Activator.CreateInstance(componentType);

        return instance;
    }
}

The MockIoc class is for demo purposes only. The types defined here, must be "sync'd" with the types defined in the 'CustomBindings`, see below. They relationships/translations are defined here, seperating concerns between the IOC and serialization framework elements.

public class CustomBinding
{
    public string Alias { get; set; }
    public Type SerializationType { get; set; }
    public Type ServiceType { get; set; }
}

The CustomBinding class holds all the information we need to define the desired translations. Note that ServiceType is the type that will be handed to the IOC container and is usually an interface or abstract class; the final translation to the desired, concrete component is defined seperately, as part of the IOC configuration.

public class CustomBindings
{
    public CustomBindings()
    {
        _bindings = new List<CustomBinding>()
        {
            new CustomBinding() { Alias = "A", SerializationType = typeof(Assembly), ServiceType = typeof(IAssembly)},
            new CustomBinding() { Alias = "B", SerializationType = typeof(Bolt), ServiceType = typeof(IBolt)},
            new CustomBinding() { Alias = "W", SerializationType = typeof(Washer), ServiceType = typeof(IWasher)},
            new CustomBinding() { Alias = "N", SerializationType = typeof(Nut), ServiceType = typeof(INut)},

        };
    }

    private readonly List<CustomBinding> _bindings;

    public String SerializedTypeToAlias(Type type) => _bindings.Single(b => b.SerializationType == type).Alias;

    public Type AliasToDeserializedType(string alias) => _bindings.Single(b => b.Alias == alias).SerializationType;

    public Type DeserializedTypeToService(Type type) => _bindings.Single(b => b.SerializationType == type).ServiceType;
}

The CustomBindings class defines the intended bindings and provides methods for translating the type information.

The types handed to SerializedTypeToAlias will be the actual class types in the current code base. The type returned by AliasToDeserializedType will determine which members are populated. The type returned by DeserializedTypeToService will be used to resolve a concrete component for the service type by the IOC container.

public class CustomSerializationBinder : ISerializationBinder
{
    private readonly CustomBindings _bindings;

    public CustomSerializationBinder(CustomBindings bindings)
    {
        _bindings = bindings;
    }
    public void BindToName(Type serializedType, out string assemblyName, out string typeName)
    {
        var alias = _bindings.SerializedTypeToAlias(serializedType);

        assemblyName = null;  // Not required for custom type aliases
        typeName = alias;
        Console.WriteLine("Binding type " + serializedType.Name + " to alias " + alias);
    }

    public Type BindToType(string assemblyName, string typeName)
    {
        var type = _bindings.AliasToDeserializedType(typeName);
        Console.WriteLine("Binding alias " + typeName + " to type " + type);
        return type;
    }
}

The CustomSerializationBinder is used by the JSON framework: BindToName is called during serialization and provides the type alias to the JSON file. BindToType is called during deserialization and determines the type to be used (by the contract resolver, see below) to specify how the created instance's members are to be populated. It is also the type handed to the IOC container. So this can be an interface, abstract class or concrete class; it is not the type will ultimately be built.

public class CustomResolver : DefaultContractResolver
{
    public CustomResolver(MockIoc ioc, CustomBindings bindings)
    {
        _ioc = ioc;
        _bindings = bindings;
    }

    private readonly MockIoc _ioc;
    private readonly CustomBindings _bindings;

    protected override JsonObjectContract CreateObjectContract(Type objectType)
    {
        JsonObjectContract contract = base.CreateObjectContract(objectType);

        // This is just to show that the CreateObjectContract method is being called
        Console.WriteLine("Created a contract for '" + objectType.Name + "'.");

        contract.DefaultCreator = () =>
        {
            var serviceType = _bindings.DeserializedTypeToService(objectType);

            // Use your IOC container here to create the instance.
            var instance = _ioc.Resolve(serviceType);

            // This is just to show that the DefaultCreator is being called
            Console.WriteLine("Resolved '" + objectType.Name + "' to a '" + instance.GetType().Name + "' instance.");

            return instance;
        };
        return contract;
    }
}

The CustomResolver class is also used by the JSON framework. The objectType handed in here is the type returned by CustomBindings.AliasToDeserializedType, see above, and determines how the newly created instance is to be populated. The actual type of that instance will be determined by the IOC, after (at least here, in my recipe) being converted again to serviceType.

public class CustomSettings : JsonSerializerSettings
{
    public CustomSettings(MockIoc ioc, CustomBindings bindings) : base()
    {
        TypeNameHandling = TypeNameHandling.Objects;
        Formatting = Formatting.Indented;
        ContractResolver = new CustomResolver(ioc, bindings);
        SerializationBinder = new CustomSerializationBinder(bindings);
    }
}

These are the settings required by the JSON framework to tie it all together. Note, of course, the ContractResolver and SerializationBinder.

Main and demo classes

public class JsonContactResolverTests
{
    public static void Main()
    {
        Assembly input = getDemoAssembly();
        var ioc = new MockIoc();
        var bindings = new CustomBindings();
        var settings = new CustomSettings(ioc, bindings);

        Console.WriteLine("----- Serializing widget tree to JSON -----");
        string json = JsonConvert.SerializeObject(input, settings);
        Console.WriteLine(json);
        Console.WriteLine();

        Console.WriteLine("----- Deserializing JSON back to widgets -----");
        using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(json)))
        using (StreamReader sr = new StreamReader(stream))
        using (JsonTextReader reader = new JsonTextReader(sr))
        {
            var serializer = JsonSerializer.Create(settings);
            var loaded = serializer.Deserialize<IAssembly>(reader);
            Console.WriteLine();
            Console.WriteLine(loaded.ToString(""));

            Console.WriteLine("----- Serializing loaded instance to JSON ----");
            string json2 = JsonConvert.SerializeObject(loaded, settings);

            Console.WriteLine("----- Comparing JSON outputs ----");
            if (json != json2) throw new Exception("JSON outputs are not the same");
            Console.WriteLine("ok");

        }
    }

    private static Assembly getDemoAssembly()
    {
        return new Assembly
        {
            Name = "Gizmo",
            Parts = new List<IWidget>
            {
                new Assembly
                {
                    Name = "Upper Doodad",
                    Parts = new List<IWidget>
                    {
                        new Bolt { Name = "UB1", HeadSize = 2, Length = 6 },
                        new Washer { Name = "UW1", Thickness = 1 },
                        new Nut { Name = "UN1", Size = 2 }
                    }
                },
                new Assembly
                {
                    Name = "Lower Doodad",
                    Parts = new List<IWidget>
                    {
                        new Bolt { Name = "LB1", HeadSize = 3, Length = 5 },
                        new Washer { Name = "LW1", Thickness = 2 },
                        new Washer { Name = "LW2", Thickness = 1 },
                        new Nut { Name = "LN1", Size = 3 }
                    }
                }
            }
        };
    }
}

public interface IWidget
{
    string Name { get; set; }
    string ToString(string indent = "");
}

public interface IAssembly : IWidget { }
public class Assembly : IAssembly
{
    public string Name { get; set; }
    public List<IWidget> Parts { get; set; }

    public string ToString(string indent = "")
    {
        var sb = new StringBuilder();
        sb.AppendLine(indent + "Assembly " + Name + ", containing the following parts:");
        if (Parts != null)
        {
            foreach (IWidget part in Parts)
            {
                sb.AppendLine(part.ToString(indent + "  "));
            }
        }
        return sb.ToString();
    }
}

public interface IBolt : IWidget { }
public class Bolt : IBolt
{
    public string Name { get; set; }
    public int HeadSize { get; set; }
    public int Length { get; set; }

    public string ToString(string indent = "")
    {
        return indent + "Bolt " + Name + " , head size + " + HeadSize + ", length " + Length;
    }
}

public interface IWasher : IWidget { }
public class Washer : IWasher
{
    public string Name { get; set; }
    public int Thickness { get; set; }

    public string ToString(string indent = "")
    {
        return indent + "Washer " + Name + ", thickness " + Thickness;
    }
}

public interface INut : IWidget { }
public class Nut : INut
{
    public string Name { get; set; }
    public int Size { get; set; }

    public string ToString(string indent = "")
    {
        return indent + "Nut " + Name + ", size " + Size;
    }
}

Finally: the binding associations may appear to be complicated or unnecessarily complex, but a) it is just a contrived repro example and b) it shows just one possible way of "interfering" with JSON's out-of-the-box behavior and the relevant points-of-entry.