open System

open System.Collections

open System.Collections.Generic

open System.Linq

open System.Text

open System.Runtime.Serialization.Formatters

open System.IO

open System.Data

open System.ComponentModel.DataAnnotations

open System.Globalization

open System.Reflection

​

open Newtonsoft.Json

open Newtonsoft.Json.Linq

open Newtonsoft.Json.Converters

open Newtonsoft.Json.Serialization

​

// https://stackoverflow.com/questions/48119433/how-serialize-to-stream-with-json-net-on-f

​

// Note: I used the following answer for guidance on how to restrict the scope of sw and json

// https://stackoverflow.com/questions/4973795/f-keyword-use-and-using

​

​

type RequireObjectPropertiesContractResolver() =

    inherit DefaultContractResolver()

​

    override __.CreateObjectContract(objectType: Type) = 

        let contract = base.CreateObjectContract objectType

        contract.ItemRequired <- System.Nullable<Required>(Required.Always)

        contract

​

    override __.CreateProperty(memberInfo: MemberInfo, memberSerialization: MemberSerialization) =

        let property = base.CreateProperty(memberInfo, memberSerialization)

        // https://stackoverflow.com/questions/20696262/reflection-to-find-out-if-property-is-of-option-type

        let isOption = property.PropertyType.IsGenericType && property.PropertyType.GetGenericTypeDefinition() = typedefof<Option<_>>

        if isOption then (

            property.Required <- Required.Default        

            property.NullValueHandling <- new System.Nullable<NullValueHandling>(NullValueHandling.Ignore)

        )

        property

type FooType = {

   id: int

   name: string 

   optional: int option 

}

​

let testRoundTrip<'T>(inputJson : string, settings : JsonSerializerSettings) =

    printfn "\nTesting round-trip of %s with JSON string:\n   %s" typeof<'T>.Name inputJson

    let obj = JsonConvert.DeserializeObject<'T>(inputJson, settings)

    let newJsonString = JsonConvert.SerializeObject(obj, settings)

    printfn "   Reserialized JSON string:\n   %s" newJsonString

​

let test<'T>(inputObj : 'T, settings : JsonSerializerSettings) =

    let inputJson = JsonConvert.SerializeObject(inputObj, settings)

    testRoundTrip<'T>(inputJson, settings)

​

let settings = new JsonSerializerSettings()

settings.ContractResolver <- new RequireObjectPropertiesContractResolver()

​

test({FooType.id = 101; name = "John"; optional = Some 5}, settings)

​

test({FooType.id = 101; name = "John"; optional = None}, settings)

​

try

​

    let badString = "{\"id\":101}"

    testRoundTrip<FooType>(badString, settings)

    raise (new InvalidOperationException("should not come here!"))

​

with | :? JsonException as ex -> 

    printfn "Caught expected exception: %s" ex.Message

​