如何从 JSON 序列化中排除属性

本文关键字：排除 属性 序列化 JSON | 更新日期: 2023-09-27 18:31:18

>我有一个DTO类，我序列化了它

Json.Serialize(MyClass)

如何排除其公共属性？

（它必须是公开的，因为我在其他地方的代码中使用它）

如何从 JSON 序列化中排除属性

如果您

使用的是 Json.Net 属性[JsonIgnore]则在序列化或反序列化时将简单地忽略字段/属性。

public class Car
{
  // included in JSON
  public string Model { get; set; }
  public DateTime Year { get; set; }
  public List<string> Features { get; set; }
  // ignored
  [JsonIgnore]
  public DateTime LastModified { get; set; }
}

或者，可以使用 DataContract 和 DataMember 属性有选择地序列化/反序列化属性/字段。

[DataContract]
public class Computer
{
  // included in JSON
  [DataMember]
  public string Name { get; set; }
  [DataMember]
  public decimal SalePrice { get; set; }
  // ignored
  public string Manufacture { get; set; }
  public int StockCount { get; set; }
  public decimal WholeSalePrice { get; set; }
  public DateTime NextShipmentDate { get; set; }
}

有关更多详细信息，请参阅 http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size

如果在 .NET 框架中使用System.Web.Script.Serialization，则可以在不应序列化的成员上放置ScriptIgnore属性。请参阅此处的示例：

考虑以下（简化）情况：

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
    [ScriptIgnore]
    public bool IsComplete
    {
        get { return Id > 0 && !string.IsNullOrEmpty(Name); }
    } 
}

在这种情况下，将仅序列化 Id 和 Name 属性，因此生成的 JSON 对象如下所示：

{ Id: 3, Name: 'Test User' }

不要忘记添加对" System.Web.Extensions"的引用以使此操作正常工作

编辑 2023-06-29：更新了答案并添加了有关 .NET 核心和 System.Text.Json 的信息

如果您不想使用某些属性修饰属性，或者您无权访问该类，或者如果您想决定在运行时序列化什么，请按以下步骤操作：

1. 在牛顿软件.Json

Newtonsoft解决方案非常简单：

//short helper class to ignore some properties from serialization
public class IgnorePropertiesResolver : DefaultContractResolver
{
    private readonly HashSet<string> ignoreProps;
    public IgnorePropertiesResolver(IEnumerable<string> propNamesToIgnore)
    {
        this.ignoreProps = new HashSet<string>(propNamesToIgnore);
    }
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);
        if (this.ignoreProps.Contains(property.PropertyName))
        {
            property.ShouldSerialize = _ => false;
        }
        return property;
    }
}

用法

JsonConvert.SerializeObject(YourObject, new JsonSerializerSettings()
        { ContractResolver = new IgnorePropertiesResolver(new[] { "Prop1", "Prop2" }) });

如果您决定使用此答案，请确保缓存ContractResolver对象，否则性能可能会受到影响。

我在这里发布了代码，以防有人想添加任何内容：https://github.com/jitbit/JsonIgnoreProps

2. 在System.Text.Json

.NET core默认使用System.Text.Json，它更快，但你没有Newtonsoft的所有灵活性。但是，这里有一些在运行时排除属性的解决方案：

  1. 在 .NET 7 及更高版本中，可以控制序列化哪些属性，如下所述：https://devblogs.microsoft.com/dotnet/system-text-json-in-dotnet-7/#example-conditional-serialization

  2. 在 .NET 6（及更低版本）中 - 您可以强制转换为接口（我个人认为最干净）或使用映射器。这两个选项都在此答案中描述 https://stackoverflow.com/a/61344654/56621

您可以使用

[ScriptIgnore]：

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    [ScriptIgnore]
    public bool IsComplete
    {
        get { return Id > 0 && !string.IsNullOrEmpty(Name); }
    }
}

在这种情况下，Id 和 name 将仅序列化

如果您不像我一样热衷于使用属性装饰代码，尤其是当您在编译时无法知道这里会发生什么时，这是我的解决方案。

使用 Javascript 序列化程序

public static class JsonSerializerExtensions
{
    public static string ToJsonString(this object target,bool ignoreNulls = true)
    {
        var javaScriptSerializer = new JavaScriptSerializer();
        if(ignoreNulls)
        {
            javaScriptSerializer.RegisterConverters(new[] { new PropertyExclusionConverter(target.GetType(), true) });
        }
        return javaScriptSerializer.Serialize(target);
    }
        
    public static string ToJsonString(this object target, Dictionary<Type, List<string>> ignore, bool ignoreNulls = true)
    {
        var javaScriptSerializer = new JavaScriptSerializer();
        foreach (var key in ignore.Keys)
        {
            javaScriptSerializer.RegisterConverters(new[] { new PropertyExclusionConverter(key, ignore[key], ignoreNulls) });
        }
        return javaScriptSerializer.Serialize(target);
    }
 }
    
    
public class PropertyExclusionConverter : JavaScriptConverter
{
    private readonly List<string> propertiesToIgnore;
    private readonly Type type;
    private readonly bool ignoreNulls;
    
    public PropertyExclusionConverter(Type type, List<string> propertiesToIgnore, bool ignoreNulls)
    {
        this.ignoreNulls = ignoreNulls;
        this.type = type;
        this.propertiesToIgnore = propertiesToIgnore ?? new List<string>();
    }
    
    public PropertyExclusionConverter(Type type, bool ignoreNulls)
        : this(type, null, ignoreNulls){}
    
    public override IEnumerable<Type> SupportedTypes
    {
        get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { this.type })); }
    }
    
    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {
       var result = new Dictionary<string, object>();
       if (obj == null)
       {
           return result;
       }
       var properties = obj.GetType().GetProperties();
       foreach (var propertyInfo in properties)
       {
           if (!this.propertiesToIgnore.Contains(propertyInfo.Name))
           {
               if(this.ignoreNulls && propertyInfo.GetValue(obj, null) == null)
               {
                     continue;
               }
               result.Add(propertyInfo.Name, propertyInfo.GetValue(obj, null));
           }
        }
        return result;
    }
    
    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        throw new NotImplementedException(); //Converter is currently only used for ignoring properties on serialization
    }
}

如果您使用的是System.Text.Json那么您可以使用[JsonIgnore] .
FQ： System.Text.Json.Serialization.JsonIgnoreAttribute

官方Microsoft文档：JsonIgnoreAttribute

如下所述：

该库作为 .NET Core 3.0 共享框架的一部分内置。
对于其他目标框架，请安装 System.Text.Json NuGet 包。该软件包支持：

  • .NET 标准 2.0 及更高版本
  • .NET Framework 4.6.1 及更高版本
  • .NET Core 2.0、2.1 和 2.2

对于 C# 9 的记录，它是[property: JsonIgnore] 

using System.Text.Json.Serialization;
public record R(
   string Text2
   [property: JsonIgnore] string Text2)

对于经典风格，它仍然只是[JsonIgnore]。

using System.Text.Json.Serialization;
public record R
{
   public string Text {get; init; }
   [JsonIgnore] 
   public string Text2 { get; init; }
}

您也可以使用 [NonSerialized] 属性 

[Serializable]
public struct MySerializableStruct
{
    [NonSerialized]
    public string hiddenField;
    public string normalField;
}

从 MS 文档：

指示不应序列化可序列化类的字段。此类不能继承。

例如，如果您使用的是 Unity（这不仅适用于 Unity），那么这适用于UnityEngine.JsonUtility 

using UnityEngine;
MySerializableStruct mss = new MySerializableStruct 
{ 
    hiddenField = "foo", 
    normalField = "bar" 
};
Debug.Log(JsonUtility.ToJson(mss)); // result: {"normalField":"bar"}

Add System.Text.Json Version for dotnet core

对于编译时，按照上述答案中的建议添加 [JsonIgnore]。

对于运行时，需要将 JsonConverter 添加到选项中。

首先，为要排除的类型创建一个 JsonConverter，例如下面的ICollection<LabMethod>

public class LabMethodConverter : JsonConverter<ICollection<LabMethod>>
{
    public override ICollection<LabMethod> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        //deserialize JSON into a ICollection<LabMethod>
        return null;
    }
    public override void Write(Utf8JsonWriter writer, ICollection<LabMethod> value, JsonSerializerOptions options)
    {
        //serialize a ICollection<LabMethod> object
        writer.WriteNullValue();
    }
}

然后在序列化 Json 时添加到选项

var options = new JsonSerializerOptions();
options.Converters.Add(new LabMethodConverter());
var new_obj = Json(new { rows = slice, total = count }, options);
相关文章：