using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization.Formatters;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Reflection;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/56764017/creating-reduced-json-from-a-bigger-json-in-c-sharp

​

//Extension methods from

//https://stackoverflow.com/questions/30304128/how-to-perform-partial-object-serialization-providing-paths-using-newtonsoft-j

​

    public static partial class JsonExtensions

    {

        public static TJToken RemoveAllExcept<TJToken>(this TJToken obj, IEnumerable<string> paths) where TJToken : JToken

        {

            if (obj == null || paths == null)

                throw new NullReferenceException();

            var keepers = new HashSet<JToken>(paths.SelectMany(path => obj.SelectTokens(path)), ObjectReferenceEqualityComparer<JToken>.Default);

​

            var keepersAndParents = new HashSet<JToken>(keepers.SelectMany(t => t.AncestorsAndSelf()), ObjectReferenceEqualityComparer<JToken>.Default);

            // Keep any token that is a keeper, or a child of a keeper, or a parent of a keeper

            // I.e. if you have a path ""$.A.B" and it turns out that B is an object, then everything

            // under B should be kept.

            foreach (var token in obj.DescendantsAndSelfReversed().Where(t => !keepersAndParents.Contains(t) && !t.AncestorsAndSelf().Any(p => keepers.Contains(p))))

                token.RemoveFromLowestPossibleParent();

​

            // Return the object itself for fluent style programming.

            return obj;

        }

​

        public static string SerializeAndSelectTokens<T>(T root, string[] paths, Formatting formatting = Formatting.None, JsonSerializerSettings settings = null)

        {

            var obj = JObject.FromObject(root, JsonSerializer.CreateDefault(settings));

​

            obj.RemoveAllExcept(paths);

​

            var json = obj.ToString(formatting);

​

            return json;

        }

​

        public static TJToken RemoveFromLowestPossibleParent<TJToken>(this TJToken node) where TJToken : JToken

        {

            if (node == null)

                return null;

            JToken toRemove;

            var property = node.Parent as JProperty;

            if (property != null)

            {

                // Also detach the node from its immediate containing property -- Remove() does not do this even though it seems like it should

                toRemove = property;

                property.Value = null;

            }

            else

            {

                toRemove = node;

            }

            if (toRemove.Parent != null)

                toRemove.Remove();

            return node;

        }

​

        public static IEnumerable<JToken> DescendantsAndSelfReversed(this JToken node)

        {

            if (node == null)

                throw new ArgumentNullException();

            return RecursiveEnumerableExtensions.Traverse(node, t => ListReversed(t as JContainer));

        }

​

        // Iterate backwards through a list without throwing an exception if the list is modified.

        static IEnumerable<T> ListReversed<T>(this IList<T> list)

        {

            if (list == null)

                yield break;

            for (int i = list.Count - 1; i >= 0; i--)

                yield return list[i];

        }

    }

​

    public static partial class RecursiveEnumerableExtensions

    {

        // Rewritten from the answer by Eric Lippert https://stackoverflow.com/users/88656/eric-lippert

        // to "Efficient graph traversal with LINQ - eliminating recursion" http://stackoverflow.com/questions/10253161/efficient-graph-traversal-with-linq-eliminating-recursion

        // to ensure items are returned in the order they are encountered.

​

        public static IEnumerable<T> Traverse<T>(

            T root,

            Func<T, IEnumerable<T>> children)

        {

            yield return root;

​

            var stack = new Stack<IEnumerator<T>>();

            try

            {

                stack.Push((children(root) ?? Enumerable.Empty<T>()).GetEnumerator());

​

                while (stack.Count != 0)

                {

                    var enumerator = stack.Peek();

                    if (!enumerator.MoveNext())

                    {

                        stack.Pop();

                        enumerator.Dispose();

                    }

                    else

                    {

                        yield return enumerator.Current;

                        stack.Push((children(enumerator.Current) ?? Enumerable.Empty<T>()).GetEnumerator());

                    }

                }

            }

            finally

            {

                foreach (var enumerator in stack)

                    enumerator.Dispose();

            }

        }

    }

​

    /// <summary>

    /// A generic object comparerer that would only use object's reference, 

    /// ignoring any <see cref="IEquatable{T}"/> or <see cref="object.Equals(object)"/>  overrides.

    /// </summary>

    public class ObjectReferenceEqualityComparer<T> : IEqualityComparer<T> where T : class

    {

        // Adapted from this answer https://stackoverflow.com/a/1890230

        // to https://stackoverflow.com/questions/1890058/iequalitycomparert-that-uses-referenceequals

        // By https://stackoverflow.com/users/177275/yurik

​

        private static readonly IEqualityComparer<T> _defaultComparer;

​

        static ObjectReferenceEqualityComparer() { _defaultComparer = new ObjectReferenceEqualityComparer<T>(); }

        public static IEqualityComparer<T> Default { get { return _defaultComparer; } }

​

        #region IEqualityComparer<T> Members

​

        public bool Equals(T x, T y)

        {

            return ReferenceEquals(x, y);

        }

​

        public int GetHashCode(T obj)

        {

            return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);

        }

​

        #endregion

    }

​

    class TestClass

    {

        public static void Test()

        {

            var input = JObject.Parse(GetInputJson());

            input.RemoveAllExcept(new [] 

                                  { 

                                      "employee[*].project[*].projectname",

                                      "employee[*].fullname.firstname",

                                  } );

            Console.WriteLine(input);

            var expectedJson = JToken.Parse(GetExpectedJson());

            Assert.IsTrue(JToken.DeepEquals(input, expectedJson));

        }   

        static string GetInputJson()

        {

            var json = @"{

""employee"": [{

        ""fullname"": {

            ""firstname"": ""abcd"",

            ""lastname"": ""defg""

        },

        ""project"": [{

                ""projectname"":""abcd_1"",

                ""datejoined"": ""2019-06-18T01:29:38.6013262+00:00"",

                ""projectmanager"": ""abcdM1"",

            }, {

                ""projectname"":""abcd_2"",

                ""datejoined"": ""2018-06-18T01:29:38.6013262+00:00"",

                ""projectmanager"": ""abcdM2"",

            }, {

                ""projectname"":""abcd_3"",

                ""datejoined"": ""2017-06-18T01:29:38.6013262+00:00"",

                ""projectmanager"": ""abcdM3"",

            }

        ]

    },{

        ""fullname"": {

            ""firstname"": ""abcd"",

            ""lastname"": ""defg""

        },

        ""project"": [{

                ""projectname"":""abcd_1"",

                ""datejoined"": ""2019-06-18T01:29:38.6013262+00:00"",

                ""projectmanager"": ""abcdM1"",

            }, {

                ""projectname"":""abcd_2"",

                ""datejoined"": ""2018-06-18T01:29:38.6013262+00:00"",

                ""projectmanager"": ""abcdM2"",

            }, {

                ""projectname"":""abcd_3"",

                ""datejoined"": ""2017-06-18T01:29:38.6013262+00:00"",

                ""projectmanager"": ""abcdM3"",

            }

        ]

      }

    ]

​

}

";

            return json;

        }

        static string GetExpectedJson()

        {

            var expectedJson = @"{

""employee"": [{

        ""fullname"": {

            ""firstname"": ""abcd"",

        },

        ""project"": [{

                ""projectname"":""abcd_1"",

            }, {

                ""projectname"":""abcd_2"",

            }, {

                ""projectname"":""abcd_3"",

            }

        ]

    },{

        ""fullname"": {

            ""firstname"": ""abcd"",

​

        },

        ""project"": [{

                ""projectname"":""abcd_1"",

​

            }, {

                ""projectname"":""abcd_2"",

​

            }, {

                ""projectname"":""abcd_3"",

​

            }

        ]

      }

    ]

}";

            return expectedJson;

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​