|
//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------
namespace System.ServiceModel.Syndication
{
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Xml;
using System.Runtime.Serialization;
using System.Xml.Serialization;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
// NOTE: This class implements Clone so if you add any members, please update the copy ctor
[TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
public class SyndicationItem : IExtensibleSyndicationObject
{
Collection<SyndicationPerson> authors;
Uri baseUri;
Collection<SyndicationCategory> categories;
SyndicationContent content;
Collection<SyndicationPerson> contributors;
TextSyndicationContent copyright;
ExtensibleSyndicationObject extensions = new ExtensibleSyndicationObject();
string id;
DateTimeOffset lastUpdatedTime;
Collection<SyndicationLink> links;
DateTimeOffset publishDate;
SyndicationFeed sourceFeed;
TextSyndicationContent summary;
TextSyndicationContent title;
public SyndicationItem()
: this(null, null, null)
{
}
public SyndicationItem(string title, string content, Uri itemAlternateLink)
: this(title, content, itemAlternateLink, null, DateTimeOffset.MinValue)
{
}
public SyndicationItem(string title, string content, Uri itemAlternateLink, string id, DateTimeOffset lastUpdatedTime)
: this(title, (content != null) ? new TextSyndicationContent(content) : null, itemAlternateLink, id, lastUpdatedTime)
{
}
public SyndicationItem(string title, SyndicationContent content, Uri itemAlternateLink, string id, DateTimeOffset lastUpdatedTime)
{
if (title != null)
{
this.Title = new TextSyndicationContent(title);
}
this.content = content;
if (itemAlternateLink != null)
{
this.Links.Add(SyndicationLink.CreateAlternateLink(itemAlternateLink));
}
this.id = id;
this.lastUpdatedTime = lastUpdatedTime;
}
protected SyndicationItem(SyndicationItem source)
{
if (source == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("source");
}
this.extensions = source.extensions.Clone();
this.authors = FeedUtils.ClonePersons(source.authors);
this.categories = FeedUtils.CloneCategories(source.categories);
this.content = (source.content != null) ? source.content.Clone() : null;
this.contributors = FeedUtils.ClonePersons(source.contributors);
this.copyright = FeedUtils.CloneTextContent(source.copyright);
this.id = source.id;
this.lastUpdatedTime = source.lastUpdatedTime;
this.links = FeedUtils.CloneLinks(source.links);
this.publishDate = source.publishDate;
if (source.SourceFeed != null)
{
this.sourceFeed = source.sourceFeed.Clone(false);
this.sourceFeed.Items = new Collection<SyndicationItem>();
}
this.summary = FeedUtils.CloneTextContent(source.summary);
this.baseUri = source.baseUri;
this.title = FeedUtils.CloneTextContent(source.title);
}
public Dictionary<XmlQualifiedName, string> AttributeExtensions
{
get { return this.extensions.AttributeExtensions; }
}
public Collection<SyndicationPerson> Authors
{
get
{
if (this.authors == null)
{
this.authors = new NullNotAllowedCollection<SyndicationPerson>();
}
return this.authors;
}
}
public Uri BaseUri
{
get { return this.baseUri; }
set { this.baseUri = value; }
}
public Collection<SyndicationCategory> Categories
{
get
{
if (this.categories == null)
{
this.categories = new NullNotAllowedCollection<SyndicationCategory>();
}
return this.categories;
}
}
public SyndicationContent Content
{
get { return content; }
set { content = value; }
}
public Collection<SyndicationPerson> Contributors
{
get
{
if (this.contributors == null)
{
this.contributors = new NullNotAllowedCollection<SyndicationPerson>();
}
return this.contributors;
}
}
public TextSyndicationContent Copyright
{
get { return this.copyright; }
set { this.copyright = value; }
}
public SyndicationElementExtensionCollection ElementExtensions
{
get { return this.extensions.ElementExtensions; }
}
public string Id
{
get { return id; }
set { id = value; }
}
public DateTimeOffset LastUpdatedTime
{
get { return lastUpdatedTime; }
set { lastUpdatedTime = value; }
}
public Collection<SyndicationLink> Links
{
get
{
if (this.links == null)
{
this.links = new NullNotAllowedCollection<SyndicationLink>();
}
return this.links;
}
}
public DateTimeOffset PublishDate
{
get { return publishDate; }
set { publishDate = value; }
}
public SyndicationFeed SourceFeed
{
get { return this.sourceFeed; }
set { this.sourceFeed = value; }
}
public TextSyndicationContent Summary
{
get { return this.summary; }
set { this.summary = value; }
}
public TextSyndicationContent Title
{
get { return this.title; }
set { this.title = value; }
}
public static SyndicationItem Load(XmlReader reader)
{
return Load<SyndicationItem>(reader);
}
public static TSyndicationItem Load<TSyndicationItem>(XmlReader reader)
where TSyndicationItem : SyndicationItem, new ()
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
Atom10ItemFormatter<TSyndicationItem> atomSerializer = new Atom10ItemFormatter<TSyndicationItem>();
if (atomSerializer.CanRead(reader))
{
atomSerializer.ReadFrom(reader);
return atomSerializer.Item as TSyndicationItem;
}
Rss20ItemFormatter<TSyndicationItem> rssSerializer = new Rss20ItemFormatter<TSyndicationItem>();
if (rssSerializer.CanRead(reader))
{
rssSerializer.ReadFrom(reader);
return rssSerializer.Item as TSyndicationItem;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnknownItemXml, reader.LocalName, reader.NamespaceURI)));
}
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "0#permalink", Justification = "permalink is a term defined in the RSS format")]
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Permalink", Justification = "permalink is a term defined in the RSS format")]
public void AddPermalink(Uri permalink)
{
if (permalink == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("permalink");
}
this.Id = permalink.AbsoluteUri;
this.Links.Add(SyndicationLink.CreateAlternateLink(permalink));
}
public virtual SyndicationItem Clone()
{
return new SyndicationItem(this);
}
public Atom10ItemFormatter GetAtom10Formatter()
{
return new Atom10ItemFormatter(this);
}
public Rss20ItemFormatter GetRss20Formatter()
{
return GetRss20Formatter(true);
}
public Rss20ItemFormatter GetRss20Formatter(bool serializeExtensionsAsAtom)
{
return new Rss20ItemFormatter(this, serializeExtensionsAsAtom);
}
public void SaveAsAtom10(XmlWriter writer)
{
this.GetAtom10Formatter().WriteTo(writer);
}
public void SaveAsRss20(XmlWriter writer)
{
this.GetRss20Formatter().WriteTo(writer);
}
protected internal virtual SyndicationCategory CreateCategory()
{
return new SyndicationCategory();
}
protected internal virtual SyndicationLink CreateLink()
{
return new SyndicationLink();
}
protected internal virtual SyndicationPerson CreatePerson()
{
return new SyndicationPerson();
}
protected internal virtual bool TryParseAttribute(string name, string ns, string value, string version)
{
return false;
}
protected internal virtual bool TryParseContent(XmlReader reader, string contentType, string version, out SyndicationContent content)
{
content = null;
return false;
}
protected internal virtual bool TryParseElement(XmlReader reader, string version)
{
return false;
}
protected internal virtual void WriteAttributeExtensions(XmlWriter writer, string version)
{
this.extensions.WriteAttributeExtensions(writer);
}
protected internal virtual void WriteElementExtensions(XmlWriter writer, string version)
{
this.extensions.WriteElementExtensions(writer);
}
internal void LoadElementExtensions(XmlReader readerOverUnparsedExtensions, int maxExtensionSize)
{
this.extensions.LoadElementExtensions(readerOverUnparsedExtensions, maxExtensionSize);
}
internal void LoadElementExtensions(XmlBuffer buffer)
{
this.extensions.LoadElementExtensions(buffer);
}
}
}
|