如何解决 F# 和 Azure Functions 之间的 JSON 转换冲突？

Question

Question:

How do I resolve JSON conversion conflicts between F# and Azure Functions?

Research:

I've reviewed several related questions. However, they tend to focus on returning a response versus sending a request.

In addition, I really don't want to decorate every single member in each record type that I have across all my client and backend services.

F# Client:

I thought I could use a contract resolver on the client to remedy the JSON conflicts. However, I failed.

let postTo (baseAddress:string) (resource:string) (payload:Object) =

    let settings = JsonSerializerSettings()
    settings.ContractResolver <- new DefaultContractResolver()

    let json = JsonConvert.SerializeObject(payload, settings);

    let encodedUrl = getAddress baseAddress resource
    let result     = GlobalHttpClient.Instance.PostAsJsonAsync(encodedUrl, json) |> toResult
    result

C# Server:

I then thought I could use a contract resolver on the server to remedy the JSON conflicts. However, I still failed.

In addition, I get exceptions when attempting to deserialize. It complains that it can't convert a string into one of my record types.

public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
    ILogger log,
    ExecutionContext context)
{
    try
    {
        using (var streamReader = new StreamReader(req.Body))
        {
            var requestBody = await streamReader.ReadToEndAsync();

            var settings = new JsonSerializerSettings();
            settings.ContractResolver = new DefaultContractResolver();

            var data = JsonConvert.DeserializeObject<DeviceOrigin>(requestBody, settings); // Exception thrown here ! ! !

            ...
        }
    }

}

Error:

Could not cast or convert from System.String to Courier.Account.Language+DeviceOrigin.

Unwanted Resolution:

As mentioned earlier , decorating the properties of record types resolves the issue but is extremely tedious for every data-transfer structure that's used in all of my solutions.

The following works if I decorate the types on both the client and the server:

[<DataContract>]
type DeviceOrigin = {

    [<field: DataMember(Name="DeviceId")>]
    DeviceId   : string

    [<field: DataMember(Name="Coordinate")>]
    Coordinate : Coordinate
}

[<DataContract>]
type Applicant = {

    [<field: DataMember(Name="ApplicantId")>]
    ApplicantId : string

    [<field: DataMember(Name="FirstName")>]
    FirstName   : string

    [<field: DataMember(Name="LastName")>]
    LastName    : string

    [<field: DataMember(Name="Phone")>]
    Phone       : string

    [<field: DataMember(Name="Email")>]
    Email       : string

    [<field: DataMember(Name="Origin")>]
    Origin      : Coordinate
}

Appendix:

Return an F# record type as JSON in Azure Functions

Serializing F# Record type to JSON includes '@' character after each property

{"ApplicantId@":"","FirstName@":"John","LastName@":"Doe","Phone@":"555.555.5555","Email@":"j.doe@abc.com","Origin@":{"Latitude@":37.421998333333335,"Longitude@":-122.08400000000002}}

Answer 1

I am not sure what exactly the problem is as the question is lacking a minimal reprodible example, but looking at the other questions it seems @ appended by F# on field members causes issues to some. I tried reproducing it on my machine but NewtonSoft.Json doesn't append @ for me. This make me think OP is running a different version of .net and/or NewtonSoft.Json on client and server which gives the problem seen.

It might be a good idea to check that Client and Server are running the same version of NewtonSoft.Json and preferably the latest.

Something that could help is providing your own NamingStrategy , this allows you to override the names serialized into Json, possibly letting you to strip the @ .

Here's the complete source code that I tried running on .NET Core 3.1 for NewtonSoft.Json 12.0.3. I don't see @ but potentially the NamingStrategy can help OP get further.

open Newtonsoft.Json
open Newtonsoft.Json.Serialization

[<CLIMutable>]
type Coordinate = 
  {
    Latitude    : float
    Longitude   : float
  }

[<CLIMutable>]
type Applicant = 
  {
    ApplicantId : string
    FirstName   : string
    LastName    : string
    Phone       : string
    Email       : string
    Origin      : Coordinate
  }
let applicant = 
  { 
    ApplicantId = "a_0001"
    FirstName   = "Hello"
    LastName    = "There"
    Phone       = "+1 555-2345"
    Email       = "a@b.com"
    Origin      = { Latitude = 23.45; Longitude = 65.43 }
  }

let jsonSerializerSettings = 
  let settings = JsonSerializerSettings ()
  let contractResolver = DefaultContractResolver ()
  // One can override the naming strategy, below prints input and output for SnakeCaseNamingStrategy
  //  One should be able to strip out the @ by providing a custom naming strategy
  let namingStrategy = 
    { new SnakeCaseNamingStrategy() with
        override x.GetDictionaryKey key =
          let key' = base.GetDictionaryKey key
          printfn "GetDictionaryKey: %A -> %A" key key'
          key'
        override x.GetExtensionDataName name = 
          let name' = base.GetExtensionDataName name
          printfn "GetExtensionDataName: %A -> %A" name name'
          name'
        override x.GetPropertyName (name, flag) = 
          let name' = base.GetPropertyName (name, flag)
          printfn "GetPropertyName: (%A, %A) -> %A" name flag name'
          name'
        override x.ResolvePropertyName name = 
          let name' = base.ResolvePropertyName name
          printfn "ResolvePropertyName: %A -> %A" name name'
          name'
    }
  contractResolver.NamingStrategy <- namingStrategy
  settings.ContractResolver <- contractResolver
  settings

let readJson (json: string): Applicant =
  JsonConvert.DeserializeObject<Applicant> (json, jsonSerializerSettings)

let writeJson (applicant: Applicant): string =
  JsonConvert.SerializeObject (applicant, jsonSerializerSettings)

[<EntryPoint>]
let main argv =
  let json = writeJson  applicant
  let app  = readJson   json

  printfn "E: %A" applicant
  printfn "J: %A" json
  printfn "A: %A" app
  0