Question

例如，我们有两个类

class FooA
{
    [SomeSpecialAttribute]
    public int SomeValueA { get; set; }

    public int SomeValueB { get; set; }

    public int SomeValueC { get; set; }
}

class FooB
{
    public FooA FooA { get; set; }
}

我使用Json.NET，最大深度为1.在序列化FooA时，它应该像往常一样输出所有属性，但是在序列化FooB时，它应该只输出一个具有特殊属性的FooA属性。因此，只有在解析嵌套引用属性（深度> 0）时，我们才能获得单个字段。

输出应该是：{＆＃34; FooA＆＃34;：{＆＃34; SomeValueA＆＃34;：＆＃34; 0＆＃34; }}

有什么想法吗？

Answer 1

这里的基本困难是Json.NET是一个基于合同的序列化程序，它为每个要序列化的类型创建一个合同，然后根据合同进行序列化。无论对象图中出现何种类型，都适用相同的合同。但是，您希望根据对象图中的深度选择性地包含给定类型的属性，这与基本的＆＃34;一种类型的合同相冲突＆＃34;设计因此需要一些工作。

实现目标的一种方法是创建一个JsonConverter，为每个对象执行默认序列化，然后沿Generic method of modifying JSON before being returned to client行修剪不需要的属性。请注意，这会导致树之类的递归结构出现问题，因为转换器必须为子节点禁用自身，以避免无限递归。

另一种可能性是创建custom IContractResolver，根据序列化深度为每种类型返回不同的合同。这必须使用serialization callbacks来跟踪对象序列化何时开始和结束，因为合同解析器不知道序列化深度：

[System.AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = true)]
public class JsonIncludeAtDepthAttribute : System.Attribute
{
    public JsonIncludeAtDepthAttribute()
    {
    }
}

public class DepthPruningContractResolver : IContractResolver
{
    readonly int depth;

    public DepthPruningContractResolver()
        : this(0)
    {
    }

    public DepthPruningContractResolver(int depth)
    {
        if (depth < 0)
            throw new ArgumentOutOfRangeException("depth");
        this.depth = depth;
    }

    [ThreadStatic]
    static DepthTracker currentTracker;

    static DepthTracker CurrentTracker { get { return currentTracker; } set { currentTracker = value; } }

    class DepthTracker : IDisposable
    {
        int isDisposed;
        DepthTracker oldTracker;

        public DepthTracker()
        {
            isDisposed = 0;
            oldTracker = CurrentTracker;
            currentTracker = this;
        }

        #region IDisposable Members

        public void Dispose()
        {
            if (0 == Interlocked.Exchange(ref isDisposed, 1))
            {
                CurrentTracker = oldTracker;
                oldTracker = null;
            }
        }
        #endregion

        public int Depth { get; set; }
    }

    abstract class DepthTrackingContractResolver : DefaultContractResolver
    {
        static DepthTrackingContractResolver() { } // Mark type with beforefieldinit.

        static SerializationCallback OnSerializing = (o, context) =>
        {
            if (CurrentTracker != null)
                CurrentTracker.Depth++;
        };

        static SerializationCallback OnSerialized = (o, context) =>
        {
            if (CurrentTracker != null)
                CurrentTracker.Depth--;
        };

        protected override JsonObjectContract CreateObjectContract(Type objectType)
        {
            var contract = base.CreateObjectContract(objectType);
            contract.OnSerializingCallbacks.Add(OnSerializing);
            contract.OnSerializedCallbacks.Add(OnSerialized);
            return contract;
        }
    }

    sealed class RootContractResolver : DepthTrackingContractResolver
    {
        // As of 7.0.1, Json.NET suggests using a static instance for "stateless" contract resolvers, for performance reasons.
        // http://www.newtonsoft.com/json/help/html/ContractResolver.htm
        // http://www.newtonsoft.com/json/help/html/M_Newtonsoft_Json_Serialization_DefaultContractResolver__ctor_1.htm
        // "Use the parameterless constructor and cache instances of the contract resolver within your application for optimal performance."
        static RootContractResolver instance;
        static RootContractResolver() { instance = new RootContractResolver(); }
        public static RootContractResolver Instance { get { return instance; } }
    }

    sealed class NestedContractResolver : DepthTrackingContractResolver
    {
        static NestedContractResolver instance;
        static NestedContractResolver() { instance = new NestedContractResolver(); }
        public static NestedContractResolver Instance { get { return instance; } }

        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
        {
            var property = base.CreateProperty(member, memberSerialization);

            if (property.AttributeProvider.GetAttributes(typeof(JsonIncludeAtDepthAttribute), true).Count == 0)
            {
                property.Ignored = true;
            }

            return property;
        }
    }

    public static IDisposable CreateTracker()
    {
        return new DepthTracker();
    }

    #region IContractResolver Members

    public JsonContract ResolveContract(Type type)
    {
        if (CurrentTracker != null && CurrentTracker.Depth > depth)
            return NestedContractResolver.Instance.ResolveContract(type);
        else
            return RootContractResolver.Instance.ResolveContract(type);
    }

    #endregion
}

然后按如下方式标记您的课程：

class FooA
{
    [JsonIncludeAtDepthAttribute]
    public int SomeValueA { get; set; }

    public int SomeValueB { get; set; }

    public int SomeValueC { get; set; }
}

class FooB
{
    public FooA FooA { get; set; }
}

序列化如下：

var settings = new JsonSerializerSettings { ContractResolver = new DepthPruningContractResolver(depth), Formatting = Formatting.Indented };

using (DepthPruningContractResolver.CreateTracker())
{
    var jsonB = JsonConvert.SerializeObject(foob, settings);
    Console.WriteLine(jsonB);

    var jsonA = JsonConvert.SerializeObject(foob.FooA, settings);
    Console.WriteLine(jsonA);
}

需要稍微笨拙CreateTracker()以确保在序列化中途抛出异常的情况下，当前对象深度会重置，并且不会影响将来对JsonConvert.SerializeObject()的调用。

Answer 2

此解决方案假定您不想更改FooA类的所有序列化。如果是这种情况，您应该创建自己的JsonConverter。

public class FooConverter : JsonConverter
{      
   public FooConveter(params Type[] parameterTypes)
   {

   }

   public override bool CanConvert(Type objectType)
   {
      return objectType.IsAssignableFrom(typeof(FooA));
   }

   public override object ReadJson(JsonReader reader, Type objectType)
   {
      //Put your code to deserialize FooA here.  
      //You probably don't need it based on the scope of your question.
   }

   public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
   {
      //Code to serialize FooA.
      if (value == null)
      {
         writer.WriteNull();
         return;
      }

      //Only serialize SomeValueA
      var foo = value as FooA;
      writer.WriteStartObject();
      writer.WritePropertyName("FooA");
      writer.Serialize(writer, foo.SomeValueA);
      writer.WriteEndObject();          
   }
}

在代码中使用转换器

class FooB
{
   [FooConverter]
   public FooA FooA { get; set; }
}

否则，您可以使用JsonIgnore属性忽略您不希望序列化的FooA字段。请记住，权衡的是，无论何时将FooA转换为Json，它都将始终忽略标记有该属性的字段。

Json.NET按深度和属性

2 个答案: