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 System.Collections.ObjectModel;

​

using MongoDB.Bson;

using MongoDB.Bson.Serialization;

using MongoDB.Bson.IO;

using MongoDB.Bson.Serialization.Serializers;

using MongoDB.Bson.Serialization.Attributes;

​

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

​

//https://stackoverflow.com/questions/59441376/deserializing-from-bsondocument-to-string-and-serializing-back-to-bsondocument

​

    public class Person

    {

        public string name { get; set; }

​

        [BsonIgnore]

        public string dob

        {

            get => BsonExtensionMethods.ToJson(SerializedDOB);

            set => SerializedDOB = MyBsonExtensionMethods.FromJson<Dob>(value);

        }

​

        [BsonElement("dob")]

        Dob SerializedDOB { get; set; }

        class Dob // The DTO

        {

            public string month { get; set; }

            public int day { get; set; }

            public int year { get; set; }

        }

    }

​

    public static partial class MyBsonExtensionMethods

    {

        // Not sure why but BsonExtensionMethods.cs seems to lack methods for deserializing from JSON, so I added some here.

        // See https://github.com/mongodb/mongo-csharp-driver/blob/master/src/MongoDB.Bson/BsonExtensionMethods.cs 

​

        public static TNominalType FromJson<TNominalType>(

            string json,

            JsonReaderSettings readerSettings = null,

            IBsonSerializer<TNominalType> serializer = null,

            Action<BsonDeserializationContext.Builder> configurator = null)

        {

            return (TNominalType)FromJson(json, typeof(TNominalType), readerSettings, serializer, configurator);

        }

​

        public static object FromJson(

            string json,

            Type nominalType,

            JsonReaderSettings readerSettings = null,

            IBsonSerializer serializer = null,

            Action<BsonDeserializationContext.Builder> configurator = null)

        {

            if (nominalType == null || json == null)

                throw new ArgumentNullException();

            serializer = serializer ?? BsonSerializer.LookupSerializer(nominalType);

            if (serializer.ValueType != nominalType)

                throw new ArgumentException(string.Format("serializer.ValueType {0} != nominalType {1}.", serializer.GetType().FullName, nominalType.FullName), "serializer");

​

            using (var textReader = new StringReader(json)) 

            using (var reader = new JsonReader(textReader, readerSettings ?? JsonReaderSettings.Defaults))

            {

                var context = BsonDeserializationContext.CreateRoot(reader, configurator);

                return serializer.Deserialize(context);

            }

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var person = new Person

            {

                name = "my name",

                dob = @"{ ""month"" : ""December"", ""day"" : 25, ""year"" : 2019 }",

            };

​

            Test(person);

​

            // Verify null works

            Test(new Person());

        }   

        static void Test(Person person)

        {

            var json = BsonExtensionMethods.ToJson(person);

​

            Console.WriteLine("Serialized {0}:", person);

            Console.WriteLine(json);

​

            var person2 = MyBsonExtensionMethods.FromJson<Person>(json);

            var json2 = BsonExtensionMethods.ToJson(person2);

​

            Assert.IsTrue(person.dob == person2.dob, "person.dob == person2.dob");

            Assert.IsTrue(json2 == json, "json2 == json");

            var bsonDoc = BsonExtensionMethods.ToBsonDocument(person2);

            var person3 = BsonSerializer.Deserialize<Person>(bsonDoc);

​

            Assert.IsTrue(person.dob == person3.dob, "person.dob == person3.dob");

​

            var json3 = BsonExtensionMethods.ToJson(person3);

​

            Assert.IsTrue(json3 == json, "json3 == json");

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine("BsonDocument version: " + typeof(BsonDocument).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.CodeBase.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​