158

我们有一些配置文件是通过使用 Json.net 序列化 C# 对象生成的。

我们希望将序列化类的一个属性从简单的枚举属性迁移到类属性中。

一种简单的方法是在类中保留旧的枚举属性，并安排 Json.net 在加载配置时读取此属性，但在下一次序列化对象时不再保存它。我们将分别处理从旧枚举生成新类。

是否有任何简单的方法来标记（例如使用属性）C# 对象的属性，以便 Json.net 仅在序列化时忽略它，但在反序列化时关注它？

4

12 回答 12

165

实际上，您可以使用几种相当简单的方法来实现您想要的结果。

例如，假设您的类当前定义如下：

class Config
{
    public Fizz ObsoleteSetting { get; set; }
    public Bang ReplacementSetting { get; set; }
}

enum Fizz { Alpha, Beta, Gamma }

class Bang
{
    public string Value { get; set; }
}

你想这样做：

string json = @"{ ""ObsoleteSetting"" : ""Gamma"" }";

// deserialize
Config config = JsonConvert.DeserializeObject<Config>(json);

// migrate
config.ReplacementSetting = 
    new Bang { Value = config.ObsoleteSetting.ToString() };

// serialize
json = JsonConvert.SerializeObject(config);
Console.WriteLine(json);

要得到这个：

{"ReplacementSetting":{"Value":"Gamma"}}

方法一：添加一个 ShouldSerialize 方法

Json.NET 具有通过ShouldSerialize在类中查找相应方法来有条件地序列化属性的能力。

要使用此功能，请向您的类添加一个布尔ShouldSerializeBlah()方法，其中Blah替换为您不想序列化的属性的名称。使这个方法的实现总是返回false。

class Config
{
    public Fizz ObsoleteSetting { get; set; }

    public Bang ReplacementSetting { get; set; }

    public bool ShouldSerializeObsoleteSetting()
    {
        return false;
    }
}

注意：如果您喜欢这种方法，但又不想通过引入ShouldSerialize方法来混淆类的公共接口，则可以使用 anIContractResolver以编程方式执行相同的操作。请参阅文档中的条件属性序列化。

方法 2：使用 JObjects 操作 JSON

无需使用JsonConvert.SerializeObject来进行序列化，而是将配置对象加载到 aJObject中，然后在将其写出之前简单地从 JSON 中删除不需要的属性。这只是几行额外的代码。

JObject jo = JObject.FromObject(config);

// remove the "ObsoleteSetting" JProperty from its parent
jo["ObsoleteSetting"].Parent.Remove();

json = jo.ToString();

方法 3：巧妙（ab）使用属性

  1. 将[JsonIgnore]属性应用于您不想被序列化的属性。
  2. 将备用的私有属性设置器添加到与原始属性具有相同类型的类。使该属性的实现设置原始属性。
  3. 将[JsonProperty]属性应用到备用设置器，为其指定与原始属性相同的 JSON 名称。

这是修改后的Config课程：

class Config
{
    [JsonIgnore]
    public Fizz ObsoleteSetting { get; set; }

    [JsonProperty("ObsoleteSetting")]
    private Fizz ObsoleteSettingAlternateSetter
    {
        // get is intentionally omitted here
        set { ObsoleteSetting = value; }
    }

    public Bang ReplacementSetting { get; set; }
}
于 2014-06-14T21:28:48.780 回答
59

对于任何可以将仅反序列化的属性标记为内部的情况，有一个非常简单的解决方案，它根本不依赖于属性。只需将属性标记为内部获取，但公共设置：

public class JsonTest {

    public string SomeProperty { internal get; set; }

}

这会导致使用默认设置/解析器/等进行正确的反序列化，但该属性会从序列化输出中剥离。

于 2018-02-27T18:29:04.023 回答
39

我喜欢在这个属性上坚持，这是我需要反序列化属性但不序列化它时使用的方法，反之亦然。

第 1 步 - 创建自定义属性

public class JsonIgnoreSerializationAttribute : Attribute { }

第 2 步 - 创建一个自定义的 Contract Reslover

class JsonPropertiesResolver : DefaultContractResolver
{
    protected override List<MemberInfo> GetSerializableMembers(Type objectType)
    {
        //Return properties that do NOT have the JsonIgnoreSerializationAttribute
        return objectType.GetProperties()
                         .Where(pi => !Attribute.IsDefined(pi, typeof(JsonIgnoreSerializationAttribute)))
                         .ToList<MemberInfo>();
    }
}

第 3 步 - 添加不需要序列化但需要反序列化的属性

    [JsonIgnoreSerialization]
    public string Prop1 { get; set; } //Will be skipped when serialized

    [JsonIgnoreSerialization]
    public string Prop2 { get; set; } //Also will be skipped when serialized

    public string Prop3 { get; set; } //Will not be skipped when serialized

第 4 步 - 使用它

var sweet = JsonConvert.SerializeObject(myObj, new JsonSerializerSettings { ContractResolver = new JsonPropertiesResolver() });

希望这可以帮助！另外值得注意的是，当反序列化发生时，这也会忽略属性，当我反序列化时，我只是以传统方式使用转换器。

JsonConvert.DeserializeObject<MyType>(myString);
于 2016-02-05T22:50:41.910 回答
8

使用 setter 属性：

[JsonProperty(nameof(IgnoreOnSerializing))]
public string IgnoreOnSerializingSetter { set { _ignoreOnSerializing = value; } }

[JsonIgnore]
private string _ignoreOnSerializing;

[JsonIgnore]
public string IgnoreOnSerializing
{
    get { return this._ignoreOnSerializing; }
    set { this._ignoreOnSerializing = value; }
}

希望这有帮助。

于 2014-06-13T10:10:20.523 回答
4

在我花了很长时间搜索如何将类属性标记为可反序列化和不可序列化之后，我发现根本没有这样的事情可以做到；所以我想出了一个结合两个不同库或序列化技术（System.Runtime.Serialization.Json & Newtonsoft.Json）的解决方案，它对我有用，如下所示：

  • 将所有类和子类标记为“DataContract”。
  • 将您的类和子类的所有属性标记为“DataMember”。
  • 将您的类和子类的所有属性标记为“JsonProperty”，除了那些您不希望它们被序列化的属性。
  • 现在将您不希望将其序列化为“JsonIgnore”的属性标记。

  • 然后使用“Newtonsoft.Json.JsonConvert.SerializeObject”进行序列化，并使用“System.Runtime.Serialization.Json.DataContractJsonSerializer”进行反序列化。

    using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using System.Runtime.Serialization;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Text;

namespace LUM_Win.model
{
    [DataContract]
    public class User
    {
        public User() { }
        public User(String JSONObject)
        {
            MemoryStream stream = new MemoryStream(Encoding.Unicode.GetBytes(JSONObject));
            DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(User));

            User user = (User)dataContractJsonSerializer.ReadObject(stream);
            this.ID = user.ID;
            this.Country = user.Country;
            this.FirstName = user.FirstName;
            this.LastName = user.LastName;
            this.Nickname = user.Nickname;
            this.PhoneNumber = user.PhoneNumber;
            this.DisplayPicture = user.DisplayPicture;
            this.IsRegistred = user.IsRegistred;
            this.IsConfirmed = user.IsConfirmed;
            this.VerificationCode = user.VerificationCode;
            this.Meetings = user.Meetings;
        }

        [DataMember(Name = "_id")]
        [JsonProperty(PropertyName = "_id")]
        public String ID { get; set; }

        [DataMember(Name = "country")]
        [JsonProperty(PropertyName = "country")]
        public String Country { get; set; }

        [DataMember(Name = "firstname")]
        [JsonProperty(PropertyName = "firstname")]
        public String FirstName { get; set; }

        [DataMember(Name = "lastname")]
        [JsonProperty(PropertyName = "lastname")]
        public String LastName { get; set; }

        [DataMember(Name = "nickname")]
        [JsonProperty(PropertyName = "nickname")]
        public String Nickname { get; set; }

        [DataMember(Name = "number")]
        [JsonProperty(PropertyName = "number")]
        public String PhoneNumber { get; set; }

        [DataMember(Name = "thumbnail")]
        [JsonProperty(PropertyName = "thumbnail")]
        public String DisplayPicture { get; set; }

        [DataMember(Name = "registered")]
        [JsonProperty(PropertyName = "registered")]
        public bool IsRegistred { get; set; }

        [DataMember(Name = "confirmed")]
        [JsonProperty(PropertyName = "confirmed")]
        public bool IsConfirmed { get; set; }

        [JsonIgnore]
        [DataMember(Name = "verification_code")]
        public String VerificationCode { get; set; }

        [JsonIgnore]
        [DataMember(Name = "meeting_ids")]
        public List<Meeting> Meetings { get; set; }

        public String toJSONString()
        {
            return JsonConvert.SerializeObject(this, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore });
        }
    }
}

希望有帮助...

于 2013-04-02T18:58:51.957 回答
3

根据应用程序中发生这种情况的位置以及如果它只是一个属性，您可以手动执行此操作的一种方法是将属性值设置为 null，然后在模型上您可以指定如果值为 null，则忽略该属性：

[JsonProperty(NullValueHandling = NullValue.Ignore)]
public string MyProperty { get; set; }

如果您正在使用 ASP.NET Core Web 应用程序，则可以通过在 Startup.cs 文件中设置它来为所有模型中的所有属性全局设置它：

public void ConfigureServices(IServiceCollection services) {
    // other configuration here
    services.AddMvc()
        .AddJsonOptions(options => options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore);
}
于 2019-05-31T17:06:00.960 回答
2

参考@ThoHo 的解决方案，实际上只需要使用setter，不需要额外的标签。

对我来说，我以前有一个引用 ID，我想加载并添加到新的引用 ID 集合中。通过将引用 Id 的定义更改为仅包含一个 setter 方法，该方法将值添加到新集合中。如果 Property 没有get，则 Json 无法将值写回；方法。

// Old property that I want to read from Json, but never write again. No getter.
public Guid RefId { set { RefIds.Add(value); } }

// New property that will be in use from now on. Both setter and getter.
public ICollection<Guid> RefIds { get; set; }

这个类现在向后兼容以前的版本，并且只保存新版本的RefId。

于 2016-11-21T03:39:43.857 回答
2

为了建立在 Tho Ho 的答案之上，这也可以用于字段。

[JsonProperty(nameof(IgnoreOnSerializing))]
public string IgnoreOnSerializingSetter { set { IgnoreOnSerializing = value; } }

[JsonIgnore]
public string IgnoreOnSerializing;
于 2017-10-26T09:20:03.717 回答
0

如果你使用 JsonConvert，IgnoreDataMemberAttribute是可以的。我的标准库不引用 Newton.Json，我使用 [IgnoreDataMember] 来控制对象序列化。

来自Newton.net帮助文档。

于 2018-12-26T05:14:28.397 回答
0

是否有任何简单的方法来标记（例如使用属性）C# 对象的属性，以便 Json.net 仅在序列化时忽略它，但在反序列化时关注它？

在撰写本文时，我发现的最简单的方法是将此逻辑包含在您的IContractResolver中。

上述链接中的示例代码复制到此处以供后代使用：

public class Employee
{
    public string Name { get; set; }
    public Employee Manager { get; set; }

    public bool ShouldSerializeManager()
    {
        // don't serialize the Manager property if an employee is their own manager
        return (Manager != this);
    }
}

public class ShouldSerializeContractResolver : DefaultContractResolver
{
    public new static readonly ShouldSerializeContractResolver Instance = new ShouldSerializeContractResolver();

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

        if (property.DeclaringType == typeof(Employee) && property.PropertyName == "Manager")
        {
            property.ShouldSerialize =
                instance =>
                {
                    Employee e = (Employee)instance;
                    return e.Manager != e;
                };
        }

        return property;
    }
}

所有的答案都很好，但这种方法似乎是最干净的方法。实际上，我通过在属性上查找 SkipSerialize 和 SkipDeserialize 的属性来实现这一点，这样您就可以标记您控制的任何类。好问题！

于 2019-06-29T04:37:21.723 回答
0

Jraco11 的回答非常简洁。如果您想对序列化和反序列化使用相同的 IContractResolver，则可以使用以下命令：

public class JsonPropertiesResolver : DefaultContractResolver
{
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);

        if (member.IsDefined(typeof(JsonIgnoreSerializationAttribute)))
        {
            property.ShouldSerialize = instance => false;
        }

        return property;
    }
}
于 2021-02-03T08:23:21.253 回答
-2

在模型类的公共属性中使用[JsonIgnore]属性。

于 2021-06-23T11:51:36.223 回答