使属性反序列化但不使用json.net序列化

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

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

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

是否有任何简单的方法来标记（例如，带有属性）C＃对象的属性，以便Json.net仅在序列化时将其忽略，而在反序列化时将其保留？

实际上，可以使用几种相当简单的方法来获得所需的结果。

例如，假设您当前定义了这样的类：

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

方法1：添加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方法弄混类的公共接口，则可以使用an IContractResolver来以编程方式执行相同的操作。请参阅文档中的条件属性序列化。

方法2：使用JObjects处理JSON

无需使用JsonConvert.SerializeObject序列化方法，JObject只需将config对象加载到中，然后在将其写出之前从JSON中删除不需要的属性即可。这只是几行额外的代码。

JObject jo = JObject.FromObject(config);

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

json = jo.ToString();

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

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

对于只将反序列化属性标记为内部的任何情况，都有一种非常简单的解决方案，它完全不依赖于属性。只需将属性标记为内部获取，但将其设为公共集即可：

public class JsonTest {

    public string SomeProperty { internal get; set; }

}

使用默认设置/解析器/等可以导致正确的反序列化，但是该属性已从序列化输出中删除。

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

步骤1-创建自定义属性

public class JsonIgnoreSerializationAttribute : Attribute { }

第2步-创建自定义合同转帐

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

使用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; }
}

希望能有所帮助。

在花了很长时间研究了如何将一个类属性标记为可反序列化和不可序列化之后，我发现根本没有这样做的事情。所以我想出了一个结合了两种不同的库或序列化技术（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 });
          }
      }
  }

希望有帮助...

参照@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。

要根据胡浩的答案，这也可以用于领域。

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

[JsonIgnore]
public string IgnoreOnSerializing;

根据发生在应用程序中的位置以及它仅仅是一个属性，您可以通过一种手动方式将属性值设置为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);
}

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

从Newton.net帮助文档。

是否有任何简单的方法来标记（例如，带有属性）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的属性上查找属性来实现的，因此您可以标记任何您控制的类。好问题！