JSON.net:如何在不使用默认构造函数的情况下进行反序列化

有点晚了，不太适合这里，但我要在这里添加我的解决方案，因为我的问题已经作为这个问题的副本关闭，而且这个解决方案完全不同。

我需要一种通用的方法来指示Json.NET为用户定义的结构类型选择最特定的构造函数，这样我就可以省略JsonConstructor属性，这将为定义每个此类结构的项目添加依赖项。

我进行了一些反向工程，并实现了一个自定义契约解析器，其中我覆盖了CreateObjectContract方法来添加我的自定义创建逻辑。

public class CustomContractResolver : DefaultContractResolver {
    protected override JsonObjectContract CreateObjectContract(Type objectType)
    {
        var c = base.CreateObjectContract(objectType);
        if (!IsCustomStruct(objectType)) return c;
        IList<ConstructorInfo> list = objectType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).OrderBy(e => e.GetParameters().Length).ToList();
        var mostSpecific = list.LastOrDefault();
        if (mostSpecific != null)
        {
            c.OverrideCreator = CreateParameterizedConstructor(mostSpecific);
            c.CreatorParameters.AddRange(CreateConstructorParameters(mostSpecific, c.Properties));
        }
        return c;
    }
    protected virtual bool IsCustomStruct(Type objectType)
    {
        return objectType.IsValueType && !objectType.IsPrimitive && !objectType.IsEnum && !objectType.Namespace.IsNullOrEmpty() && !objectType.Namespace.StartsWith("System.");
    }
    private ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method)
    {
        method.ThrowIfNull("method");
        var c = method as ConstructorInfo;
        if (c != null)
            return a => c.Invoke(a);
        return a => method.Invoke(null, a);
    }
}

我是这样用的。

public struct Test {
  public readonly int A;
  public readonly string B;
  public Test(int a, string b) {
    A = a;
    B = b;
  }
}
var json = JsonConvert.SerializeObject(new Test(1, "Test"), new JsonSerializerSettings {
  ContractResolver = new CustomContractResolver()
});
var t = JsonConvert.DeserializeObject<Test>(json);
t.A.ShouldEqual(1);
t.B.ShouldEqual("Test");

基于这里的一些答案，我编写了一个CustomConstructorResolver，用于当前项目，我认为它可能会帮助其他人。

它支持以下所有可配置的解析机制：

• 选择单个私有构造函数，这样就可以定义一个私有构造函数，而不必用属性标记它
• 选择最具体的私有构造函数，这样您就可以有多个重载，而不必使用属性
• 选择用特定名称的属性标记的构造函数——类似于默认的解析器，但不依赖Json.Net包，因为您需要引用Newtonsoft.Json.JsonConstructorAttribute

public class CustomConstructorResolver : DefaultContractResolver
{
    public string ConstructorAttributeName { get; set; } = "JsonConstructorAttribute";
    public bool IgnoreAttributeConstructor { get; set; } = false;
    public bool IgnoreSinglePrivateConstructor { get; set; } = false;
    public bool IgnoreMostSpecificConstructor { get; set; } = false;
    protected override JsonObjectContract CreateObjectContract(Type objectType)
    {
        var contract = base.CreateObjectContract(objectType);
        // Use default contract for non-object types.
        if (objectType.IsPrimitive || objectType.IsEnum) return contract;
        // Look for constructor with attribute first, then single private, then most specific.
        var overrideConstructor = 
               (this.IgnoreAttributeConstructor ? null : GetAttributeConstructor(objectType)) 
            ?? (this.IgnoreSinglePrivateConstructor ? null : GetSinglePrivateConstructor(objectType)) 
            ?? (this.IgnoreMostSpecificConstructor ? null : GetMostSpecificConstructor(objectType));
        // Set override constructor if found, otherwise use default contract.
        if (overrideConstructor != null)
        {
            SetOverrideCreator(contract, overrideConstructor);
        }
        return contract;
    }
    private void SetOverrideCreator(JsonObjectContract contract, ConstructorInfo attributeConstructor)
    {
        contract.OverrideCreator = CreateParameterizedConstructor(attributeConstructor);
        contract.CreatorParameters.Clear();
        foreach (var constructorParameter in base.CreateConstructorParameters(attributeConstructor, contract.Properties))
        {
            contract.CreatorParameters.Add(constructorParameter);
        }
    }
    private ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method)
    {
        var c = method as ConstructorInfo;
        if (c != null)
            return a => c.Invoke(a);
        return a => method.Invoke(null, a);
    }
    protected virtual ConstructorInfo GetAttributeConstructor(Type objectType)
    {
        var constructors = objectType
            .GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
            .Where(c => c.GetCustomAttributes().Any(a => a.GetType().Name == this.ConstructorAttributeName)).ToList();
        if (constructors.Count == 1) return constructors[0];
        if (constructors.Count > 1)
            throw new JsonException($"Multiple constructors with a {this.ConstructorAttributeName}.");
        return null;
    }
    protected virtual ConstructorInfo GetSinglePrivateConstructor(Type objectType)
    {
        var constructors = objectType
            .GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic);
        return constructors.Length == 1 ? constructors[0] : null;
    }
    protected virtual ConstructorInfo GetMostSpecificConstructor(Type objectType)
    {
        var constructors = objectType
            .GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
            .OrderBy(e => e.GetParameters().Length);
        var mostSpecific = constructors.LastOrDefault();
        return mostSpecific;
    }
}

以下是以XML文档为要点的完整版本：https://gist.github.com/bjorn-jarisch/80f77f4b6bdce3b434b0f7a1d06baa95

感谢反馈。

Newtonsoft.Json的默认行为是查找public构造函数。如果您的默认构造函数仅用于包含类或同一程序集，则可以将访问级别降低为protected或internal，以便Newtonsoft.Json选择您想要的public构造函数。

诚然，这种解决方案仅限于特定情况。

internal Result() { }
public Result(int? code, string format, Dictionary<string, string> details = null)
{
    Code = code ?? ERROR_CODE;
    Format = format;
    if (details == null)
        Details = new Dictionary<string, string>();
    else
        Details = details;
}

根据Zoltan的回答，我创建了一个变体，允许您使用基于其签名的特定构造函数。

使用

return new JsonSerializerSettings
{
    ContractResolver = new DynamicObjectResolver(t =>
    {
        if (t == typeof(QueueProperties))
            return new Type[] { typeof(string) };
        return null;
    })
};

这里是的实现

using Newtonsoft.Json.Serialization;
using System;
using System.Collections.Concurrent;
using System.Reflection;
namespace ConsoleApp76.Json
{
    class DynamicObjectResolver : DefaultContractResolver
    {
        private readonly Func<Type, Type[]> GetConstructorSignature;
        private readonly ConcurrentDictionary<Type, ConstructorInfo> TypeToConstructorLookup =
            new ConcurrentDictionary<Type, ConstructorInfo>();
        public DynamicObjectResolver(Func<Type, Type[]> getConstructorSignature)
        {
            if (getConstructorSignature is null)
                throw new ArgumentNullException(nameof(getConstructorSignature));
            GetConstructorSignature = getConstructorSignature;
        }
        protected override JsonObjectContract CreateObjectContract(Type objectType)
        {
            var result = base.CreateObjectContract(objectType);
            ConstructorInfo constructor = TypeToConstructorLookup.GetOrAdd(objectType, t => FindConstructorInfo(t));
            if (constructor is null)
                return result;
            result.OverrideCreator = CreateParameterizedConstructor(constructor);
            foreach (var param in CreateConstructorParameters(constructor, result.Properties))
                result.CreatorParameters.Add(param);
            return result;
        }
        private ConstructorInfo FindConstructorInfo(Type objectType)
        {
            Type[] constructorSignature = GetConstructorSignature(objectType);
            if (constructorSignature is null)
                return null;
            return objectType.GetConstructor(
                bindingAttr:
                    System.Reflection.BindingFlags.Public
                    | System.Reflection.BindingFlags.NonPublic
                    | System.Reflection.BindingFlags.Instance,
                binder: null,
                types: new Type[] { typeof(string) },
                modifiers: null);
        }
        private static ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method)
        {
            if (method is null)
                throw new ArgumentNullException(nameof(method));
            var c = method as ConstructorInfo;
            if (c != null)
                return a => c.Invoke(a);
            return a => method.Invoke(null, a);
        }
    }
}

解决方案：

public Response Get(string jsonData) {
    var json = JsonConvert.DeserializeObject<modelname>(jsonData);
    var data = StoredProcedure.procedureName(json.Parameter, json.Parameter, json.Parameter, json.Parameter);
    return data;
}

型号：

public class modelname {
    public long parameter{ get; set; }
    public int parameter{ get; set; }
    public int parameter{ get; set; }
    public string parameter{ get; set; }
}