使用json.net序列化對象並使用jsonignore

Question

您好，我和JSON有問題。

在Json.Net

，我們應該有一個類序列化類

當我有多個類和類有一些屬性的對象，我想有一個列表中的一個類是這樣的：

public class test 
{ 
    public int id { get; set; } 
    public string name { get; set; } 
    public string lname { get; set; } 
} 

它應該是：

public List<test> get() 
{ 
    test t = new test(); 
    t.id = 2; 
    t.lname = "jahany"; 
    t.name = "amir"; 
    return new List<test>() { t }; 
} 

但是當我有例如兩個階級，我喜歡這兩個階級的清單，我應該創建一個類中的特定屬性有比如兩類prpperty：

public class test1 
{ 
    public int id { get; set; } 
    public string name { get; set; } 
} 


public class local1 
{ 
    List<test> lst1; 
    List<test1> lst2; 
    public List<local1> get() 
    { 
     local1 l = new local1(); 
     test t = new test(); 
     t.id = 2; 
     t.lname="jahany" 
     test1 t1 = new test1(); 
     t1.name = "amir"; 
     t.id = 123; 
     l.lst1.Add(t); 
     l.lst2.Add(t1); 
     return new List<local1>(l); 
    } 
} 

而且你知道這兩個類的所有屬性是serealise，但我喜歡toignore一些屬性的序列化，而不是創建新的類做這個 我該怎麼辦？

Answer 1

我想了解的問題。起初我認爲這是關於序列化過程中忽略字段的問題。但在閱讀你的評論後，我不認爲這是個問題。

如果我沒有弄錯，那麼你想序列化一個類是一個混合類（test和test1）。目前您正在使用一個對象（local1）來包裝這兩個列表。但是你想要的是一個列表（帶或不帶對象包裝）。如果我錯了，請糾正我。

從我原來的答案的方法序列化爲一個列表，但不是作爲類的混合。所以你不能將它恢復到混合類的列表，因爲你沒有這些信息。所有這些都是容器類。

所以你需要的是混合類和維護類信息。

爲此，您可以使用一個接口：

public interface baseClass 
{ 
} 

實現兩類接口：

public class test : baseClass 
{ 
    public int id { get; set; } 
    public string name { get; set; } 
    public string lname { get; set; } 
} 

public class test1 : baseClass 
{ 
    public int id { get; set; } 
    public string name { get; set; } 
} 

，並創建列表：

var lst = new List<baseClass>(); 
lst.Add(new test { id = 2, lname = "jahany" }); 
lst.Add(new test1 { name = "amir", id = 123 }); 

現在你」需要強制串行器添加類型信息，但只在必要時：

var settings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto }; 
var s = JsonConvert.SerializeObject(lst, settings); 

其中s返回類似：

[ 
    {"$type":"test","id":2,"name":null,"lname":"jahany"}, 
    {"$type":"test1","id":123,"name":"amir"} 
] 

哪些可以反序列化爲混合類的列表。

這是你在追求什麼？

- 原來的答案 -

您可以使用System.ComponentModel.DefaultValueAttribute。這適用於xml和json。

這個想法是從序列化輸出中省略了具有默認值的屬性。這將允許您爲不同目的定製輸出，而無需爲每個差異創建新模型。在反序列化中，應該使用默認值恢復省略的字段。

該值必須與缺省值匹配才能省略。這就是爲什麼你實際上必須分配一個默認值。

public class test 
{ 
    [DefaultValue(0)] 
    public int id { get; set; } = 0; 

    public string name { get; set; } 

    [DefaultValue(null)] 
    public string lname { get; set; } = null; 
} 

請注意，name = null和lname = null的結果是相同的。兩者都沒有序列化。如果爲0，則省略id。在反序列化id中，值爲0，這恰好是default（int）。序列化對象時

DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate 

它會忽略成員，其中成員值是一樣的成員的默認值，並設置成員的默認值反序列化時：

爲了使這項工作在JSON格式的配置設置。

如何使用：

public List<test> get() 
{ 
    return new List<test>() { new test 
    { 
     id = 2, 
     lname = "jahany", 
     name = "amir" 
    } }; 
} 

爲了省去LNAME只跳過領域：

public List<test> get2() 
{ 
    return new List<test>() { new test 
    { 
     id = 2, 
     //lname = "jahany", 
     name = "amir" 
    } }; 
} 

Answer 2

您可以使用要忽略哪個屬性DefaultContractResolver定製：

public class IgnorePropertiesContractResolver<T> : DefaultContractResolver 
{ 
    private IReadOnlyList<string> ignoredProperties; 

    public IgnorePropertiesContractResolver(params string[] properties) 
    { 
     ignoredProperties = properties.ToList(); 
    } 

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

     if (member.DeclaringType == typeof(T) && ignoredProperties.Contains(member.Name)) 
     { 
      property.Ignored = true; 
     } 

     return property; 
    } 
} 

用法：

var json1 = "{id: 1, name: 'qwe', lname: 'qwe'}"; 
var json2 = "{id: 2, name: 'asd', lname: 'asd'}"; 


var ignoreLName = new JsonSerializerSettings 
{ 
    ContractResolver = new IgnorePropertiesContractResolver<test>("lname") 
}; 

var tests = new List<test>(); 
tests.Add(JsonConvert.DeserializeObject<test>(json1)); 
tests.Add(JsonConvert.DeserializeObject<test>(json2, ignoreLName)); 

Answer 3

，可以忽略任何財產。
只是將其標記：

public class test 
{ 
    public int id { get; set; } 
    public string name { get; set; } 
    public virtual string lname { get; set; } 
} 
public class test1 : test 
{ 
    [JsonIgnore] 
    public override string lname { get; set; } 
} 
var list = new List<test>() 
{ 
    new test() {id = 1, name = "name1", lname = "lname1"}, 
    new test1() {id = 2, name = "name2", lname = "lname2"} 
}; 
var s = JsonConvert.SerializeObject(list); 

結果：

[{ 
    "id": 1, 
    "name": "name1", 
    "lname": "lname1" 
}, { 
    "id": 2, 
    "name": "name2" 
}]