using System;

using Newtonsoft.Json;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Linq;

using System.Collections.Generic;

using System.Data;

using System.Linq;

using System.Runtime.Serialization;

​

public class Program

{

    public interface IApplicationData { }

    public class ApplicationData : IApplicationData {

        public string ExampleData { get; set; }

        public override string ToString() {

            return ExampleData; 

        }

    }

    #region Tasks

    public interface ITask {

        IApplicationData Data { get; }

    }

    [DataContract]

    public abstract class Task : ITask, ICloneable {

        protected Task(IApplicationData data = null) {

            Data = data;

        }

        public IApplicationData Data { get; }

​

        public object Clone() {

            var settings = new JsonSerializerSettings() {

                TypeNameHandling = TypeNameHandling.All

            };

            settings.Converters.Add(new TaskCreator(Data));

​

            var json = JsonConvert.SerializeObject(this, settings);

​

            // Reflection equivalent of JsonConvert.DeserializeObject<T>(json, settings);

            var expectedParameters = new Type[] { typeof(string), typeof(JsonSerializerSettings) };

            var method = typeof(JsonConvert).GetMethods().Where(mi => mi.IsGenericMethod && mi.IsStatic && mi.IsPublic && mi.GetParameters().Select(pi => pi.ParameterType).SequenceEqual(expectedParameters)).Single();

            return method.MakeGenericMethod(this.GetType()).Invoke(null, new object[] { json, settings });

        }

    }

    public class NoDataTask : Task {

        public NoDataTask() { }

    }

    public class DataTask : Task {

        public DataTask(IApplicationData data) : base(data) { }

    }

    #endregion

    public class TaskCreator : JsonConverter<ITask> {

    private readonly IApplicationData _data;

    public TaskCreator(IApplicationData data) {

        _data = data;

    }

​

    public override ITask ReadJson(JsonReader reader, Type objectType, ITask existingValue, bool hasExistingValue, JsonSerializer serializer) {

        if (reader.TokenType == JsonToken.Null) {

            return null;

        }

​

        // Determine and create the task by reading the type in the JSON

        var jObj = JObject.Load(reader);

        var jsonType = jObj["$type"]?.ToString();

        if (string.IsNullOrWhiteSpace(jsonType)) throw new JsonSerializationException("Cannot determine type of task to create.");

        var type = Type.GetType(jsonType);

        if (type == null) throw new JsonSerializationException($"Could not find the task type {jsonType}");

        var value = Create(type);

        if (value == null) throw new JsonSerializationException("No object created.");

​

        reader = jObj.CreateReader();

        serializer.Populate(reader, value);

        return value;

    }

​

    /// <summary>

    /// Creates an object which will then be populated by the serializer.

    /// </summary>

    /// <param name="objectType">Type of the object.</param>

    /// <returns>The created object.</returns>

    public ITask Create(Type objectType) {

        var hasDataConstructor = objectType.GetConstructor(new Type[] { typeof(IApplicationData) }) != null;

        return hasDataConstructor ? (ITask)Activator.CreateInstance(objectType, _data) : (ITask)Activator.CreateInstance(objectType);

    }

​

    /// <summary>

    /// Writes the JSON representation of the object.

    /// </summary>

    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>

    /// <param name="value">The value.</param>

    /// <param name="serializer">The calling serializer.</param>

    public override void WriteJson(JsonWriter writer, ITask value, JsonSerializer serializer) {

        throw new NotSupportedException($"{ nameof(TaskCreator) } should only be used while deserializing.");

    }

​

    /// <summary>

    /// Gets a value indicating whether this <see cref="JsonConverter"/> can write JSON.

    /// </summary>

    /// <value>

    ///     <c>true</c> if this <see cref="JsonConverter"/> can write JSON; otherwise, <c>false</c>.

    /// </value>

    public override bool CanWrite => false;

}

    [DataContract]

    public class Project {

        [DataMember]

        //[JsonProperty(ItemConverterType = typeof(TaskCreator))] // uncomment to force use of converter

        public List<ITask> Tasks { get; set; }

    }

    public static void Main()

    {

        var data = new ApplicationData { ExampleData = "Hello World" };

        var dataTask = new DataTask(data);

        var dataTaskCloneData = ((DataTask)dataTask.Clone()).Data; // still has data intact - excellent

        Console.WriteLine($"{nameof(dataTaskCloneData)}: {dataTaskCloneData}");

        var project = new Project {

            Tasks = new List<ITask> {

                new NoDataTask(),

                new DataTask(data)

            }

        };

​

        var serialiserSettings = new JsonSerializerSettings {

            TypeNameHandling = TypeNameHandling.All

        };

        serialiserSettings.Converters.Add(new TaskCreator(data));

​

        var json = JsonConvert.SerializeObject(project, serialiserSettings);

        var projectCopy = JsonConvert.DeserializeObject<Project>(json, serialiserSettings);

​

        var projectCopyTask2Data = projectCopy.Tasks[1].Data; // data is null - bad

        Console.WriteLine($"{nameof(projectCopyTask2Data)}: {projectCopyTask2Data}");

    }

}