Question

我有一个我序列化的DTO类

Json.Serialize(MyClass)

如何排除公开属性？

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

Answer 1

如果您使用的是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

Answer 2

如果您在.NET框架中使用System.Web.Script.Serialization ，则可以在不应序列化的成员上添加ScriptIgnore属性。请参阅取自here的示例：

考虑以下（简化）案例：
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”的引用以使其正常工作

Answer 3

您可以使用[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); }
    }
}

参考here

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

Answer 4

如果你不像我那样热衷于使用Attributes来装饰代码，尤其是当你在编译时无法告诉我这里会发生什么是我的解决方案。

使用Javascript Serializer

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

Answer 5

对不起，我决定再写一个答案，因为其他答案都没有足够的可粘贴粘贴性。

如果您不想用某些属性来装饰属性，或者您无权访问该类，或者您想要确定在运行时序列化什么，等等。等等。这是在Newtonsoft中的方法。杰森

//short helper class to ignore some properties from serialization
public class IgnorePropertiesResolver : DefaultContractResolver
{
    private IEnumerable<string> _propsToIgnore;
    public IgnorePropertiesResolver(IEnumerable<string> propNamesToIgnore)
    {
        _propsToIgnore = propNamesToIgnore;
    }
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);
        property.ShouldSerialize = (x) => { return !_propsToIgnore.Contains(property.PropertyName); };
        return property;
    }
}

用法

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

如果有人要添加任何内容，我已经在这里发布了代码

https://github.com/jitbit/JsonIgnoreProps

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

Answer 6

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

Microsoft官方文档：JsonIgnoreAttribute

如here所述：

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


.NET Standard 2.0和更高版本

.NET Framework 4.6.1和更高版本

.NET Core 2.0、2.1和2.2

Answer 7

您还可以使用[NonSerialized]属性

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

From the MS docs：

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

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

一起使用

using UnityEngine;

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

Answer 8

为 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);

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

8 个答案: