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 Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

//https://stackoverflow.com/questions/52127580/how-to-create-json-string-form-c-sharp-list-of-object-with-specific-properties

​

    class TestClass

    {

        public static void Test()

        {

            var dropDownList = new[] { "Customer.Id", "Customer.FirstName", "Customer.LastName", "Customer.Address.AddressLine1", "Customer.Address.AddressLine2" };

​

            var selectedDropDownValues = new[] { "Customer.Id", "Customer.FirstName", "Customer.Address.AddressLine1" };

​

            var customerDBList = new [] {

                            new {

                                Id=1,

                                FirstName="John",

                                LastName="Desouza",

                                Address=new {            

                                            AddressLine1="1 Street",

                                            AddressLine2="Linking Road"

                                }},        

                            new {

                                Id=2,

                                FirstName="Sam",

                                LastName="Lewis",

                                Address=new {            

                                            AddressLine1="Fedral Highway",

                                            AddressLine2="Louisville"

                                }                

                            }};         

            var rootName = "Customer";

            var query = customerDBList

                // Convert to JObject

                .Select(c => JObject.FromObject(c))

                // Add additional level of object nesting { "Customer": { ... } } 

                .Select(o => new JObject( new JProperty(rootName, o)))

                // Remove all but selected properties.

                .Select(o => o.RemoveAllExcept(selectedDropDownValues));

            var json = JsonConvert.SerializeObject(query, Formatting.Indented);

            Console.WriteLine("Generated JSON: ");

            Console.WriteLine(json);

            var requiredJson = @"[

  {

    ""Customer"": {

      ""Id"": 1,

      ""FirstName"": ""John"",

      ""Address"": {

        ""AddressLine1"": ""1 Street""

      }

    }

  },

  {

    ""Customer"": {

      ""Id"": 2,

      ""FirstName"": ""Sam"",

      ""Address"": {

        ""AddressLine1"": ""Fedral Highway""

      }

    }

  }

]";         

            Assert.IsTrue(JToken.DeepEquals(JToken.Parse(json), JToken.Parse(requiredJson)), "Generated JSON is NOT equivalent to required JSON!");

            Console.WriteLine("\nGenerated JSON is equivalent to required JSON.");

        }

    }

​

    // Taken from 

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

    // https://stackoverflow.com/a/30333562/3744182

​

    public static class JsonExtensions

    {

        public static JObject RemoveAllExcept(this JObject obj, IEnumerable<string> paths)

        {

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

                throw new NullReferenceException();

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

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

            // 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 void RemoveFromLowestPossibleParent(this JToken node)

        {

            if (node == null)

                throw new ArgumentNullException();

            var contained = node.AncestorsAndSelf().Where(t => t.Parent is JArray || t.Parent is JObject).FirstOrDefault();

            if (contained != null)

                contained.Remove();

        }

​

        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();

            }

        }

    }

​

    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;

            }

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            IsTrue(value, "failed");

        }

​

        public static void IsTrue(bool value, string message)

        {

            if (value == false)

                throw new AssertionFailedException(message ?? "failed");

        }

    }

​