如何从Json序列化排除属性

我有一个DTO类，我序列化

Json.Serialize(MyClass)

如何排除它的公共属性?

(它必须是公共的，因为我在其他地方的代码中使用它)

408168 次浏览
小开

你可以使用[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和名称只会被序列化

小开

如果你在.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' }

PS。不要忘记添加一个引用"System.Web.Extensions"要让它起作用

小开
最佳答案

[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

小开

如果你不像我一样热衷于用属性装饰代码，尤其是当你不能在编译时告诉你会发生什么，这是我的解决方案。

使用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
}
}
小开

你也可以使用[NonSerialized]属性

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

来自微软文档:

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

例如，如果你使用Unity (这不仅仅适用于Unity)，那么这适用于UnityEngine.JsonUtility

using UnityEngine;


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

如果你正在使用System.Text.Json，那么你可以使用[JsonIgnore] FQ: System.Text.Json.Serialization.JsonIgnoreAttribute

官方微软文档: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
小开

抱歉，我决定再写一个答案，因为其他答案都不能复制粘贴。

如果你不想用一些属性装饰属性，或者如果你无法访问类，或者如果你想决定在运行时序列化什么，等等，等等，这里是你如何在Newtonsoft做它。Json

//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

小开

为dotnet核心添加System.Text.Json版本

对于编译时，根据上面的答案添加[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);
小开

对于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; }
}

提交答案