c# - 无法将 Json 反序列化为类型，无法找到构造函数

Question

我在反序列化发送到 azure 函数的 JSON 时遇到了一些问题。首先，我打算将一组密文类型的 post 发送到 azure，反序列化 JSON 以恢复我的数据，然后对该数据进行操作。我的类如下所示，名为 sampleClass，它具有类型为 Ciphertext 的属性 ciphertext :

[DataContract]
public class sampleClass
{
    [DataMember]
    public Ciphertext ciphertext { get; set; }
    [JsonConstructor]
    public sampleClass() { }
} 

这是我尝试序列化/反序列化的类。

为了发布数据，我使用 HttpClient 并将其发布为 JSON，如下所示:

HttpResponseMessage response = await client.PostAsJsonAsync("api/Function1", cipher);

在我的azure函数中，我试图将Json作为流读取并将其反序列化为sampleClass[]，但是这给我带来了一个错误。

//Receive data from The Http PostRequest.
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();

//De serialises to an object.
sampleClass[] array = JsonConvert.DeserializeObject<sampleClass[]>(requestBody);

抛出的错误如下所示:

Executed 'Function1' (Failed, Id=1be7633e-6b6a-4626-98b7-8fec98eac633) [11/02/2020 15:50:48] System.Private.CoreLib: Exception while executing function: Function1. Newtonsoft.Json: Unable to find a constructor to use for type Microsoft.Research.SEAL.Ciphertext. A class should either have a default constructor, one constructor with arguments or a constructor marked with the JsonConstructor attribute. Path '[0].ciphertext.CoeffModCount', line 1, position 32.

当我尝试反序列化 JSON 时抛出此错误，如何解决此问题？

Answer 1

您这里有几个问题。让我们按顺序排列它们。

首先，输入 Microsoft.Research.SEAL.Ciphertext 既没有无参数构造函数，也没有单参数构造函数，从 reference source 可以看出:

public class Ciphertext : NativeObject
{
    public Ciphertext(MemoryPoolHandle pool = null)
    {
        // Contents omitted
    }

    public Ciphertext(SEALContext context, MemoryPoolHandle pool = null)
    {
        // Contents omitted
    }

    // Additional constructors, methods and members omitted.

第一个构造函数的参数是可选的，但这并不意味着它是无参数的，它只是意味着编译器在代码中不存在该值时提供该值。但是，当通过反射调用构造函数时(Json.NET 就是这样做的)，仍然需要提供一个值；参见 Reflection - Call constructor with parameters 了解详情。此类型缺乏真正的无参数构造函数，导致抛出 Newtonsoft.Json: Unable to find a constructor to use for type Microsoft.Research.SEAL.Ciphertext. 异常。

(评论中指出您的问题是 sampleClass 缺少默认构造函数，但该评论是错误的。)

因为您无法修改Ciphertext提供您自己的构造方法的标准方法是使用 CustomCreationConverter<T> 像这样:

public class CiphertextConverter : CustomCreationConverter<Ciphertext>
{
    public override Ciphertext Create(Type objectType)
    {
        return new Ciphertext(); // Use the default value for the optional parameter
    }
}

然后执行:

var settings = new JsonSerializerSettings
{
    Converters = { new CiphertextConverter() },
};
var array = JsonConvert.DeserializeObject<sampleClass []>(requestBody, settings);

但是，这不起作用，这是您的下一个问题。由于Ciphertext的大部分公共(public)属性是只读的，无法从它们反序列化类型。

演示 fiddle #1 失败 here .

那么，该怎么办呢？事实证明，Ciphertext有两种方法

• public long Save(Stream stream, ComprModeType? comprMode = null)
• public long Load(SEALContext context, Stream stream)

这些似乎允许我们序列化 Ciphertext到 MemoryStream ，然后使用如下转换器将内容作为 Base64 字符串插入到 JSON 中:

public class CiphertextConverter : JsonConverter<Ciphertext>
{
    readonly SEALContext context;
    
    public CiphertextConverter(SEALContext context) => this.context = context ?? throw new ArgumentNullException(nameof(context));

    public override Ciphertext ReadJson(JsonReader reader, Type objectType, Ciphertext existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        var data = serializer.Deserialize<byte []>(reader);
        if (data == null)
            return null;
        var cipherText = new Ciphertext();
        using (var stream = new MemoryStream(data))
            cipherText.Load(context, stream);
        return cipherText;
    }

    public override void WriteJson(JsonWriter writer, Ciphertext value, JsonSerializer serializer)
    {
        using (var stream = new MemoryStream())
        {
            value.Save(stream, ComprModeType.Deflate); // TODO: test to see whether Deflate gives better size vs speed performance in practice.
            writer.WriteValue(stream.ToArray());
        }
    }
}

然后在序列化和反序列化过程中使用转换器，如下所示:

var settings = new JsonSerializerSettings
{
    Converters = { new CiphertextConverter(GlobalContext.Context) },
};              
var array = JsonConvert.DeserializeObject<sampleClass []>(requestBody, settings);

但是等等——这个物体是什么GlobalContext.Context ？这给我们带来了第三个问题，即您需要兼容 SEALContext 客户端和服务器端的对象传递 Ciphertext然后通过序列化。现在，浏览Cloud Functions Demo演示应用程序，这似乎是一个正确的假设，因为该应用程序在客户端和服务器端都有兼容的上下文:

• 客户端:https://github.com/microsoft/SEAL-Demo/blob/master/CloudFunctionsDemo/ClientBasedFunctions/ClientBasedFunctions/GlobalProperties.cs
• 服务器端:https://github.com/microsoft/SEAL-Demo/blob/master/CloudFunctionsDemo/CloudBasedFunctions/CloudBasedFunctions/GlobalProperties.cs

所以我假设您也这样做。鉴于您这样做，上面的转换器应该用于序列化和反序列化。

出于测试目的，我调整了测试方法 CiphertextTests.SaveLoadTest() 和类(class) GlobalContext 来自https://github.com/microsoft/SEAL/tree/master/dotnet/tests创建以下测试工具:

public class TestClass
{
    [TestMethod]
    public void JsonNetSaveLoadTest()
    {
        Debug.WriteLine("Testing Json.NET");
        
        Func<Ciphertext, SEALContext, Ciphertext> roundtrip = (cipher, context) =>
        {
            var clientArray = new [] { new sampleClass { ciphertext = cipher } };

            var settings = new JsonSerializerSettings
            {
                Converters = { new CiphertextConverter(GlobalContext.Context) },
            };
            
            var requestBody = JsonConvert.SerializeObject(clientArray, settings);
            
            Debug.Write("   ");
            Debug.WriteLine(requestBody);
            Debug.WriteLine("   requestBody.Length={0}", requestBody.Length);
            
            var array = JsonConvert.DeserializeObject<sampleClass []>(requestBody, settings);
            
            Assert.IsTrue(array.Length == clientArray.Length);
            
            var reserializedJson = JsonConvert.SerializeObject(array, settings);
            
            Debug.Write("   ");
            Debug.WriteLine(reserializedJson);
            
            Assert.IsTrue(requestBody == reserializedJson);

            return array[0].ciphertext;
        };
        
        SaveLoadTest(roundtrip);
        
        Console.WriteLine("   passed.");
    }
    
    // Adapted from https://github.com/microsoft/SEAL/blob/master/dotnet/tests/CiphertextTests.cs#L113
    [TestMethod]
    public void DirectSaveLoadTest()
    {
        Debug.WriteLine("Testing direct save and load:");
        
        Func<Ciphertext, SEALContext, Ciphertext> roundtrip = (cipher, context) =>
        {
            Ciphertext loaded = new Ciphertext();

            Assert.AreEqual(0ul, loaded.Size);
            Assert.AreEqual(0ul, loaded.PolyModulusDegree);
            Assert.AreEqual(0ul, loaded.CoeffModCount);

            using (MemoryStream mem = new MemoryStream())
            {
                cipher.Save(mem);

                mem.Seek(offset: 0, loc: SeekOrigin.Begin);

                loaded.Load(context, mem);
            }
            return loaded;
        };
        
        SaveLoadTest(roundtrip);
        
        Debug.WriteLine("   passed.");
    }
    
    // Adapted from https://github.com/microsoft/SEAL/blob/master/dotnet/tests/CiphertextTests.cs#L113
    static void SaveLoadTest(Func<Ciphertext, SEALContext, Ciphertext> roundtrip)
    {
        SEALContext context = GlobalContext.Context;
        KeyGenerator keygen = new KeyGenerator(context);
        Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
        Plaintext plain = new Plaintext("2x^3 + 4x^2 + 5x^1 + 6");
        Ciphertext cipher = new Ciphertext();

        encryptor.Encrypt(plain, cipher);

        Assert.AreEqual(2ul, cipher.Size);
        Assert.AreEqual(8192ul, cipher.PolyModulusDegree);
        Assert.AreEqual(4ul, cipher.CoeffModCount);

        var loaded = roundtrip(cipher, context);
        
        Assert.AreEqual(2ul, loaded.Size);
        Assert.AreEqual(8192ul, loaded.PolyModulusDegree);
        Assert.AreEqual(4ul, loaded.CoeffModCount);
        Assert.IsTrue(ValCheck.IsValidFor(loaded, context));

        ulong ulongCount = cipher.Size * cipher.PolyModulusDegree * cipher.CoeffModCount;
        for (ulong i = 0; i < ulongCount; i++)
        {
            Assert.AreEqual(cipher[i], loaded[i]);
        }
    }
}

static class GlobalContext
{
    // Copied from https://github.com/microsoft/SEAL/blob/master/dotnet/tests/GlobalContext.cs
    static GlobalContext()
    {
        EncryptionParameters encParams = new EncryptionParameters(SchemeType.BFV)
        {
            PolyModulusDegree = 8192,
            CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree: 8192)
        };
        encParams.SetPlainModulus(65537ul);
        BFVContext = new SEALContext(encParams);

        encParams = new EncryptionParameters(SchemeType.CKKS)
        {
            PolyModulusDegree = 8192,
            CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree: 8192)
        };
        CKKSContext = new SEALContext(encParams);
    }

    public static SEALContext BFVContext { get; private set; } = null;
    public static SEALContext CKKSContext { get; private set; } = null;
    
    public static SEALContext Context => BFVContext;
}

工作演示 fiddle #2 here .

注释:

• 只要是public，就不需要标记sampleClass的无参构造函数。与 [JsonConstructor] .

• 根据测试，为 Ciphertext 生成的 Base64 字符串似乎很长，每个 Ciphertext 大约 0.5 MB 。由于 Json.NET 在解析过程中完全具体化了每个字符串，因此它在处理如此大的字符串时效率并不高。如果超过 maximum effective string length，您将需要重新评估您的架构或经验large object heap fragmentation .

免责声明

我不是安全专家。我无法告诉你是否发送序列化Ciphertext通过网络可能会泄露信息。我也无法建议您如何选择合适的 SEALContext对于您的应用程序 - 甚至客户端和服务器端具有兼容的上下文是否可能泄漏信息。这个答案仅解释如何通过 Json.NET 序列化特定的 SEAL 对象。