/
Atom10ItemFormatter.cs
153 lines (124 loc) · 4.71 KB
/
Atom10ItemFormatter.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics.CodeAnalysis;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
namespace System.ServiceModel.Syndication
{
[XmlRoot(ElementName = Atom10Constants.EntryTag, Namespace = Atom10Constants.Atom10Namespace)]
public class Atom10ItemFormatter : SyndicationItemFormatter, IXmlSerializable
{
private readonly Atom10FeedFormatter _feedSerializer = new Atom10FeedFormatter();
private bool _preserveAttributeExtensions = true;
private bool _preserveElementExtensions = true;
public Atom10ItemFormatter() : this(typeof(SyndicationItem))
{
}
public Atom10ItemFormatter(Type itemTypeToCreate) : base()
{
if (itemTypeToCreate is null)
{
throw new ArgumentNullException(nameof(itemTypeToCreate));
}
if (!typeof(SyndicationItem).IsAssignableFrom(itemTypeToCreate))
{
throw new ArgumentException(SR.Format(SR.InvalidObjectTypePassed, nameof(itemTypeToCreate), nameof(SyndicationItem)), nameof(itemTypeToCreate));
}
ItemType = itemTypeToCreate;
}
public Atom10ItemFormatter(SyndicationItem itemToWrite) : base(itemToWrite)
{
ItemType = itemToWrite.GetType();
}
public bool PreserveAttributeExtensions
{
get => _preserveAttributeExtensions;
set
{
_preserveAttributeExtensions = value;
_feedSerializer.PreserveAttributeExtensions = value;
}
}
public bool PreserveElementExtensions
{
get => _preserveElementExtensions;
set
{
_preserveElementExtensions = value;
_feedSerializer.PreserveElementExtensions = value;
}
}
public override string Version => SyndicationVersions.Atom10;
protected Type ItemType { get; }
public override bool CanRead(XmlReader reader)
{
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
return reader.IsStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace);
}
XmlSchema IXmlSerializable.GetSchema() => null;
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
ReadItem(reader);
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
if (writer is null)
{
throw new ArgumentNullException(nameof(writer));
}
WriteItem(writer);
}
public override void ReadFrom(XmlReader reader)
{
if (!CanRead(reader))
{
throw new XmlException(SR.Format(SR.UnknownItemXml, reader.LocalName, reader.NamespaceURI));
}
ReadItem(reader);
}
public override void WriteTo(XmlWriter writer)
{
if (writer is null)
{
throw new ArgumentNullException(nameof(writer));
}
writer.WriteStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace);
WriteItem(writer);
writer.WriteEndElement();
}
protected override SyndicationItem CreateItemInstance() => CreateItemInstance(ItemType);
private void ReadItem(XmlReader reader)
{
SetItem(CreateItemInstance());
_feedSerializer.ReadItemFrom(XmlDictionaryReader.CreateDictionaryReader(reader), Item);
}
private void WriteItem(XmlWriter writer)
{
if (Item == null)
{
throw new InvalidOperationException(SR.ItemFormatterDoesNotHaveItem);
}
XmlDictionaryWriter w = XmlDictionaryWriter.CreateDictionaryWriter(writer);
_feedSerializer.WriteItemContents(w, Item);
}
}
[XmlRoot(ElementName = Atom10Constants.EntryTag, Namespace = Atom10Constants.Atom10Namespace)]
public class Atom10ItemFormatter<TSyndicationItem> : Atom10ItemFormatter where TSyndicationItem : SyndicationItem, new()
{
public Atom10ItemFormatter() : base(typeof(TSyndicationItem))
{
}
public Atom10ItemFormatter(TSyndicationItem itemToWrite) : base(itemToWrite)
{
}
protected override SyndicationItem CreateItemInstance() => new TSyndicationItem();
}
}