/// <summary>
/// Loads this <see cref="MyCustomRssFeed"/> instance asynchronously using the specified <see cref="Uri"/>, <see cref="SyndicationResourceLoadSettings"/>, <see cref="ICredentials"/>, and <see cref="IWebProxy"/>.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="MyCustomRssFeed"/> instance. This value can be <b>null</b>.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="userToken">A user-defined object that is passed to the method invoked when the asynchronous operation completes.</param>
/// <remarks>
/// <para>
/// To receive notification when the operation has completed or the operation has been canceled, add an event handler to the <see cref="Loaded"/> event.
/// You can cancel a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> operation by calling the <see cref="LoadAsyncCancel()"/> method.
/// </para>
/// <para>
/// After calling <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/>,
/// you must wait for the load operation to complete before attempting to load the syndication resource using the <see cref="LoadAsync(Uri, Object)"/> method.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="InvalidOperationException">This <see cref="MyCustomRssFeed"/> has a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> call in progress.</exception>
public void LoadAsync(Uri source, SyndicationResourceLoadSettings settings, WebRequestOptions options, Object userToken)
{
Guard.ArgumentNotNull(source, "source");
if (settings == null)
{
settings = new SyndicationResourceLoadSettings();
}
if (this.LoadOperationInProgress)
{
throw new InvalidOperationException();
}
this.LoadOperationInProgress = true;
this.AsyncLoadHasBeenCancelled = false;
asyncHttpWebRequest = SyndicationEncodingUtility.CreateWebRequest(source, options);
asyncHttpWebRequest.Timeout = Convert.ToInt32(settings.Timeout.TotalMilliseconds, System.Globalization.NumberFormatInfo.InvariantInfo);
object[] state = new object[6] {
asyncHttpWebRequest, this, source, settings, options, userToken
};
IAsyncResult result = asyncHttpWebRequest.BeginGetResponse(new AsyncCallback(AsyncLoadCallback), state);
ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(AsyncTimeoutCallback), state, settings.Timeout, true);
}
/// <summary>
/// Initializes the syndication extension using the supplied <see cref="IXPathNavigable"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <b>IXPathNavigable</b> used to load this <see cref="AtomPublishingControlSyndicationExtension"/>.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="AtomPublishingControlSyndicationExtension"/> was able to be initialized using the supplied <paramref name="source"/>; otherwise <b>false</b>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(IXPathNavigable source, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
//------------------------------------------------------------
// Attempt to extract syndication extension information
//------------------------------------------------------------
if (settings == null)
{
settings = new SyndicationResourceLoadSettings();
}
XPathNavigator navigator = source.CreateNavigator();
wasLoaded = this.Context.Load(navigator, this.CreateNamespaceManager(navigator), settings);
//------------------------------------------------------------
// Raise extension loaded event
//------------------------------------------------------------
SyndicationExtensionLoadedEventArgs args = new SyndicationExtensionLoadedEventArgs(source, this);
this.OnExtensionLoaded(args);
return(wasLoaded);
}
/// <summary>
/// Loads this <see cref="BlogMLAuthor"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="BlogMLAuthor"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="BlogMLAuthor"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
bool wasLoaded = false;
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
if (BlogMLUtility.FillCommonObject(this, source, settings))
{
wasLoaded = true;
}
if (source.HasAttributes)
{
string emailAttribute = source.GetAttribute("email", String.Empty);
if (!String.IsNullOrEmpty(emailAttribute))
{
this.EmailAddress = emailAttribute;
wasLoaded = true;
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return(wasLoaded);
}
/// <summary>
/// Initializes a new instance of the <see cref="Atom03SyndicationResourceAdapter"/> class using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="navigator">A read-only <see cref="XPathNavigator"/> object for navigating through the syndication feed information.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="AtomFeed"/>.</param>
/// <remarks>
/// This class expects the supplied <paramref name="navigator"/> to be positioned on the XML element that represents a <see cref="AtomFeed"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public Atom03SyndicationResourceAdapter(XPathNavigator navigator, SyndicationResourceLoadSettings settings)
: base(navigator, settings)
{
//------------------------------------------------------------
// Initialization and argument validation handled by base class
//------------------------------------------------------------
}
/// <summary>
/// Loads this <see cref="ApmlApplication"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="ApmlApplication"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlApplication"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
bool wasLoaded = false;
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
if (BlogMLUtility.FillCommonObject(this, source, settings))
{
wasLoaded = true;
}
if (source.HasAttributes)
{
string urlAttribute = source.GetAttribute("url", String.Empty);
if (!String.IsNullOrEmpty(urlAttribute))
{
Uri url;
if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out url))
{
this.Url = url;
wasLoaded = true;
}
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return(wasLoaded);
}
/// <summary>
/// Loads this <see cref="AtomIcon"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="AtomIcon"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomIcon"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
wasLoaded = this.Load(source);
//------------------------------------------------------------
// Attempt to extract syndication extension information
//------------------------------------------------------------
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return(wasLoaded);
}
private static void caryVideoChecker(object source, ElapsedEventArgs e)
{
SyndicationResourceLoadSettings settings = new SyndicationResourceLoadSettings();
settings.RetrievalLimit = 1;
Uri feedUrl = new Uri("https://www.youtube.com/feeds/videos.xml?user=carykh");
AtomFeed feed = AtomFeed.Create(feedUrl, settings);
var videos = feed.Entries;
bool alreadyPosted = false;
if (videos.Count() == 0)
{
Console.WriteLine("[Error] Feed contained no information.");
}
foreach (var video in videos)
{
try
{
string videoUrlsFile = Directory.GetCurrentDirectory() + "/videoUrls.txt"; // String for the video URLS to check if a post is new, uses "videoUrls.txt" in directory the .exe is run from by default
var logFile = File.ReadAllLines(videoUrlsFile);
List <string> videoUrls = new List <string>(logFile);
string newVideoUrl = video.Links.FirstOrDefault().Uri.ToString();
string videoTitle = video.Title.Content;
foreach (var videoUrl in videoUrls)
{
if (newVideoUrl == videoUrl)
{
alreadyPosted = true;
}
}
try
{
if (alreadyPosted == false)
{
Console.WriteLine($"Found new video URL - {newVideoUrl} (\"{videoTitle}\") - Sending to discord");
using (StreamWriter text = File.AppendText(videoUrlsFile))
text.WriteLine(newVideoUrl);
_client.GetServer(184755239952318464).GetChannel(185111014671515649).SendMessage("@everyone `carykh` has uploaded a new YouTube video!\n" +
$"\"{videoTitle}\" - {newVideoUrl}");
}
}
catch (Exception error)
{
Console.WriteLine($"[Error] Bot ran into an issue while trying to post the video to discord. {error.ToString()}");
}
}
catch (Exception error)
{
Console.WriteLine("[Error] An error occured during the video check -" + error.ToString());
}
}
}
/// <summary>
/// Loads this <see cref="ApmlApplication"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="ApmlApplication"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlApplication"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
bool wasLoaded = false;
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
if (BlogMLUtility.FillCommonObject(this, source, settings))
{
wasLoaded = true;
}
if (source.HasAttributes)
{
string parentRefAttribute = source.GetAttribute("parentref", String.Empty);
string descriptionAttribute = source.GetAttribute("description", String.Empty);
if (!String.IsNullOrEmpty(parentRefAttribute))
{
this.ParentId = parentRefAttribute;
wasLoaded = true;
}
if (!String.IsNullOrEmpty(descriptionAttribute))
{
this.Description = descriptionAttribute;
wasLoaded = true;
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return(wasLoaded);
}
/// <summary>
/// Initializes a new instance of the <see cref="SyndicationExtensionAdapter"/> class using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="navigator">A read-only <see cref="XPathNavigator"/> object for navigating through the extended syndication resource information.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="IExtensibleSyndicationObject"/>.</param>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public SyndicationExtensionAdapter(XPathNavigator navigator, SyndicationResourceLoadSettings settings)
{
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(settings, "settings");
adapterNavigator = navigator;
adapterSettings = settings;
}
/// <summary>
/// Called when a corresponding asynchronous load operation completes.
/// </summary>
/// <param name="result">The result of the asynchronous operation.</param>
private static void AsyncLoadCallback(IAsyncResult result)
{
System.Text.Encoding encoding = System.Text.Encoding.UTF8;
XPathNavigator navigator = null;
WebRequest httpWebRequest = null;
MyCustomRssFeed feed = null;
Uri source = null;
WebRequestOptions options = null;
SyndicationResourceLoadSettings settings = null;
if (result.IsCompleted)
{
object[] parameters = (object[])result.AsyncState;
httpWebRequest = parameters[0] as WebRequest;
feed = parameters[1] as MyCustomRssFeed;
source = parameters[2] as Uri;
settings = parameters[3] as SyndicationResourceLoadSettings;
options = parameters[4] as WebRequestOptions;
object userToken = parameters[5];
if (feed != null)
{
WebResponse httpWebResponse = (WebResponse)httpWebRequest.EndGetResponse(result);
using (Stream stream = httpWebResponse.GetResponseStream())
{
if (settings != null)
{
encoding = settings.CharacterEncoding;
}
using (StreamReader streamReader = new StreamReader(stream, encoding))
{
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.IgnoreComments = true;
readerSettings.IgnoreWhitespace = true;
readerSettings.DtdProcessing = DtdProcessing.Ignore;
using (XmlReader reader = XmlReader.Create(streamReader, readerSettings))
{
if (encoding == System.Text.Encoding.UTF8)
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, null);
}
else
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, settings.CharacterEncoding);
}
// Code to load the syndication resource using the XPathNavigator would go here.
// If you support legacy formats, you would use a SyndicationResourceAdapter to fill the feed;
// otherwise you would utilize the feed's Load method.
feed.OnFeedLoaded(new SyndicationResourceLoadedEventArgs(navigator, source, options, userToken));
}
}
}
feed.LoadOperationInProgress = false;
}
}
}
/// <summary>
/// Loads the syndication resource from the specified <see cref="IXPathNavigable"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <b>IXPathNavigable</b> used to load the syndication resource.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="MyCustomRssFeed"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// After the load operation has successfully completed, the <see cref="MyCustomRssFeed.Loaded"/> event will be raised.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception>
public void Load(IXPathNavigable source, SyndicationResourceLoadSettings settings)
{
Guard.ArgumentNotNull(source, "source");
if (settings == null)
{
settings = new SyndicationResourceLoadSettings();
}
XPathNavigator navigator = source.CreateNavigator();
this.Load(navigator, settings, new SyndicationResourceLoadedEventArgs(navigator));
}
//============================================================
// CONSTRUCTORS
//============================================================
#region SyndicationResourceAdapter(XPathNavigator navigator, SyndicationResourceLoadSettings settings)
/// <summary>
/// Initializes a new instance of the <see cref="SyndicationResourceAdapter"/> class using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="navigator">A read-only <see cref="XPathNavigator"/> object for navigating through the syndication resource information.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="ISyndicationResource"/>.</param>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public SyndicationResourceAdapter(XPathNavigator navigator, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(settings, "settings");
adapterNavigator = navigator;
adapterSettings = settings;
}
/// <summary>
/// Initializes a new instance of the <see cref="SyndicationExtensionAdapter"/> class using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="navigator">A read-only <see cref="XPathNavigator"/> object for navigating through the extended syndication resource information.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="IExtensibleSyndicationObject"/>.</param>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public SyndicationExtensionAdapter(XPathNavigator navigator, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(settings, "settings");
adapterNavigator = navigator;
adapterSettings = settings;
}
/// <summary>
/// Loads the syndication resource using the specified <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="navigator">A read-only <see cref="XPathNavigator"/> object for navigating through the syndication resource information.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="MyCustomRssFeed"/>.</param>
/// <param name="eventData">A <see cref="SyndicationResourceLoadedEventArgs"/> that contains the event data used when raising the <see cref="MyCustomRssFeed.Loaded"/> event.</param>
/// <remarks>
/// After the load operation has successfully completed, the <see cref="MyCustomRssFeed.Loaded"/> event is raised using the specified <paramref name="eventData"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="eventData"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="navigator"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
private void Load(XPathNavigator navigator, SyndicationResourceLoadSettings settings, SyndicationResourceLoadedEventArgs eventData)
{
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(settings, "settings");
Guard.ArgumentNotNull(eventData, "eventData");
// Code to load the syndication resource using the XPathNavigator would go here.
// If you support legacy formats, you would use a SyndicationResourceAdapter to fill the feed;
// otherwise you would utilize the feed's Load method.
this.OnFeedLoaded(eventData);
}
/// <summary>
/// Loads the syndication resource from the specified <see cref="Stream"/>.
/// </summary>
/// <param name="stream">The <b>Stream</b> used to load the syndication resource.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="MyCustomRssFeed"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// After the load operation has successfully completed, the <see cref="MyCustomRssFeed.Loaded"/> event will be raised.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="stream"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="stream"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception>
public void Load(Stream stream, SyndicationResourceLoadSettings settings)
{
Guard.ArgumentNotNull(stream, "stream");
if (settings != null)
{
this.Load(SyndicationEncodingUtility.CreateSafeNavigator(stream, settings.CharacterEncoding), settings);
}
else
{
this.Load(SyndicationEncodingUtility.CreateSafeNavigator(stream), settings);
}
}
/// <summary>
/// Loads this <see cref="AtomMemberResources"/> using the supplied <see cref="XmlReader"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="reader">The <b>XmlReader</b> used to load this <see cref="AtomMemberResources"/>.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="AtomMemberResources"/> was able to be initialized using the supplied <paramref name="reader"/>; otherwise <b>false</b>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="reader"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XmlReader reader, SyndicationResourceLoadSettings settings)
{
Guard.ArgumentNotNull(reader, "reader");
if (settings == null)
{
settings = new SyndicationResourceLoadSettings();
}
XPathDocument document = new XPathDocument(reader);
return(this.Load(document.CreateNavigator(), settings));
}
/// <summary>
/// Loads this <see cref="AtomEntry"/> instance asynchronously using the specified <see cref="Uri"/>, <see cref="SyndicationResourceLoadSettings"/>, <see cref="ICredentials"/>, and <see cref="IWebProxy"/>.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="AtomEntry"/> instance. This value can be <b>null</b>.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="userToken">A user-defined object that is passed to the method invoked when the asynchronous operation completes.</param>
/// <remarks>
/// <para>
/// To receive notification when the operation has completed or the operation has been canceled, add an event handler to the <see cref="AtomEntry.Loaded"/> event.
/// You can cancel a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> operation by calling the <see cref="LoadAsyncCancel()"/> method.
/// </para>
/// <para>
/// After calling <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/>,
/// you must wait for the load operation to complete before attempting to load the syndication resource using the <see cref="AtomEntry.LoadAsync(Uri, Object)"/> method.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="InvalidOperationException">This <see cref="AtomEntry"/> has a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> call in progress.</exception>
public new void LoadAsync(Uri source, SyndicationResourceLoadSettings settings, WebRequestOptions options, Object userToken)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
//------------------------------------------------------------
// Use default settings if none specified by the caller
//------------------------------------------------------------
if (settings == null)
{
settings = new SyndicationResourceLoadSettings();
}
//------------------------------------------------------------
// Validate syndication resource state
//------------------------------------------------------------
if (this.LoadOperationInProgress)
{
throw new InvalidOperationException();
}
//------------------------------------------------------------
// Indicate that a load operation is in progress
//------------------------------------------------------------
this.LoadOperationInProgress = true;
//------------------------------------------------------------
// Reset the asynchronous load operation cancelled indicator
//------------------------------------------------------------
this.AsyncLoadHasBeenCancelled = false;
//------------------------------------------------------------
// Build HTTP web request used to retrieve the syndication resource
//------------------------------------------------------------
asyncHttpWebRequest = SyndicationEncodingUtility.CreateWebRequest(source, options);
asyncHttpWebRequest.Timeout = Convert.ToInt32(settings.Timeout.TotalMilliseconds, System.Globalization.NumberFormatInfo.InvariantInfo);
//------------------------------------------------------------
// Get the async response to the web request
//------------------------------------------------------------
object[] state = new object[6] {
asyncHttpWebRequest, this, source, settings, options, userToken
};
IAsyncResult result = asyncHttpWebRequest.BeginGetResponse(new AsyncCallback(AsyncLoadCallback), state);
//------------------------------------------------------------
// Register the timeout callback
//------------------------------------------------------------
ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(AsyncTimeoutCallback), state, settings.Timeout, true);
}
/// <summary>
/// Loads this <see cref="AtomLogo"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="AtomLogo"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomLogo"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
bool wasLoaded = false;
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
wasLoaded = this.Load(source);
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return(wasLoaded);
}
/// <summary>
/// Loads this <see cref="ApmlApplication"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="ApmlApplication"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlApplication"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract common attributes information
//------------------------------------------------------------
if (BlogMLUtility.FillCommonObject(this, source, settings))
{
wasLoaded = true;
}
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
if (source.HasAttributes)
{
string parentRefAttribute = source.GetAttribute("parentref", String.Empty);
string descriptionAttribute = source.GetAttribute("description", String.Empty);
if (!String.IsNullOrEmpty(parentRefAttribute))
{
this.ParentId = parentRefAttribute;
wasLoaded = true;
}
if (!String.IsNullOrEmpty(descriptionAttribute))
{
this.Description = descriptionAttribute;
wasLoaded = true;
}
}
//------------------------------------------------------------
// Attempt to extract syndication extension information
//------------------------------------------------------------
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return(wasLoaded);
}
/// <summary>
/// Loads this <see cref="ApmlApplication"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="ApmlApplication"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlApplication"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract common attributes information
//------------------------------------------------------------
if (BlogMLUtility.FillCommonObject(this, source, settings))
{
wasLoaded = true;
}
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
if (source.HasAttributes)
{
string urlAttribute = source.GetAttribute("url", String.Empty);
if (!String.IsNullOrEmpty(urlAttribute))
{
Uri url;
if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out url))
{
this.Url = url;
wasLoaded = true;
}
}
}
//------------------------------------------------------------
// Attempt to extract syndication extension information
//------------------------------------------------------------
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return(wasLoaded);
}
/// <summary>
/// Loads this <see cref="OpmlOutline"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="OpmlOutline"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="OpmlOutline"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
bool wasLoaded = false;
Guard.ArgumentNotNull(source, "source");
if (source.HasAttributes)
{
XPathNavigator attributesNavigator = source.CreateNavigator();
if (attributesNavigator.MoveToFirstAttribute())
{
if (this.LoadAttribute(attributesNavigator))
{
wasLoaded = true;
}
while (attributesNavigator.MoveToNextAttribute())
{
if (this.LoadAttribute(attributesNavigator))
{
wasLoaded = true;
}
}
}
}
if (source.HasChildren)
{
XPathNodeIterator outlinesIterator = source.Select("outline");
if (outlinesIterator != null && outlinesIterator.Count > 0)
{
while (outlinesIterator.MoveNext())
{
OpmlOutline outline = new OpmlOutline();
if (outline.Load(outlinesIterator.Current, settings))
{
this.Outlines.Add(outline);
wasLoaded = true;
}
}
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return(wasLoaded);
}
/// <summary>
/// Initializes the syndication extension using the supplied <see cref="XmlReader"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="reader">The <b>XmlReader</b> used to load this <see cref="AtomPublishingControlSyndicationExtension"/>.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="AtomPublishingControlSyndicationExtension"/> was able to be initialized using the supplied <paramref name="reader"/>; otherwise <b>false</b>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="reader"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XmlReader reader, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(reader, "reader");
//------------------------------------------------------------
// Create navigator against reader and pass to load method
//------------------------------------------------------------
if (settings == null)
{
settings = new SyndicationResourceLoadSettings();
}
XPathDocument document = new XPathDocument(reader);
return(this.Load(document.CreateNavigator(), settings));
}
/// <summary>
/// Loads the syndication resource from the supplied <see cref="Uri"/> using the specified <see cref="ICredentials">credentials</see>, <see cref="IWebProxy">proxy</see> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that points to the location of the web resource used to load the syndication resource.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="AtomEntry"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// <para>
/// <list type="bullet">
/// <item>
/// <description>
/// If <paramref name="settings"/> has a <see cref="SyndicationResourceLoadSettings.CharacterEncoding">character encoding</see> of <see cref="System.Text.Encoding.UTF8"/>
/// the character encoding of the <paramref name="source"/> will be attempt to be determined automatically, otherwise the specified character encoding will be used.
/// If automatic detection fails, a character encoding of <see cref="System.Text.Encoding.UTF8"/> is used by default.
/// </description>
/// </item>
/// <item>
/// <description>
/// After the load operation has successfully completed, the <see cref="AtomEntry.Loaded"/> event will be raised.
/// </description>
/// </item>
/// </list>
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the entry remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the entry remains empty.</exception>
public new void Load(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings)
{
base.Load(source, options, settings);
AtomPublishingEditedSyndicationExtension editedExtension = this.FindExtension(AtomPublishingEditedSyndicationExtension.MatchByType) as AtomPublishingEditedSyndicationExtension;
if (editedExtension != null)
{
this.EditedOn = editedExtension.Context.EditedOn;
}
AtomPublishingControlSyndicationExtension controlExtension = this.FindExtension(AtomPublishingControlSyndicationExtension.MatchByType) as AtomPublishingControlSyndicationExtension;
if (controlExtension != null)
{
this.IsDraft = controlExtension.Context.IsDraft;
}
}
/// <summary>
/// Loads the syndication resource from the supplied <see cref="Uri"/> using the specified <see cref="ICredentials">credentials</see>, <see cref="IWebProxy">proxy</see> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that points to the location of the web resource used to load the syndication resource.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="MyCustomRssFeed"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// <para>
/// <list type="bullet">
/// <item>
/// <description>
/// If <paramref name="settings"/> has a <see cref="SyndicationResourceLoadSettings.CharacterEncoding">character encoding</see> of <see cref="System.Text.Encoding.UTF8"/>
/// the character encoding of the <paramref name="source"/> will be attempt to be determined automatically, otherwise the specified character encoding will be used.
/// If automatic detection fails, a character encoding of <see cref="System.Text.Encoding.UTF8"/> is used by default.
/// </description>
/// </item>
/// <item>
/// <description>
/// After the load operation has successfully completed, the <see cref="MyCustomRssFeed.Loaded"/> event will be raised.
/// </description>
/// </item>
/// </list>
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception>
public void Load(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings)
{
XPathNavigator navigator = null;
Guard.ArgumentNotNull(source, "source");
if (settings == null)
{
settings = new SyndicationResourceLoadSettings();
}
if (settings.CharacterEncoding == System.Text.Encoding.UTF8)
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, null);
}
else
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, settings.CharacterEncoding);
}
this.Load(navigator, settings, new SyndicationResourceLoadedEventArgs(navigator, source, options));
}
public static IEnumerable <TitleAndUrl> BuildTitleAndUrls(Opml opml)
{
var titleAndUrls = new List <TitleAndUrl>();
foreach (var opmlOutline in opml.Outlines)
{
var titleAndUrl = new TitleAndUrl();
titleAndUrls.Add(titleAndUrl);
titleAndUrl.Podcasts = new List <Podcast>();
if (opmlOutline.Attributes.ContainsKey(TitleAttribute))
{
titleAndUrl.Title = opmlOutline.Attributes[TitleAttribute];
}
if (!opmlOutline.Attributes.ContainsKey(XmlUrlAttribute))
{
continue;
}
titleAndUrl.Url = new Uri(opmlOutline.Attributes[XmlUrlAttribute]);
if (titleAndUrl.Title != null)
{
continue;
}
var settings = new SyndicationResourceLoadSettings();
var feed = RssFeed.Create(titleAndUrl.Url, settings);
foreach (var item in feed.Channel.Items)
{
var podcast = new Podcast();
podcast.Title = item.Title;
podcast.Url = item.Link;
titleAndUrl.Podcasts.Add(podcast);
}
}
return(titleAndUrls);
}
/// <summary>
///
/// </summary>
/// <param name="feedUrl"></param>
/// <param name="numberOfItems"></param>
/// <returns></returns>
public ContenidoRssFeed ReadFeed(string feedUrl, int numberOfItems)
{
var settings = new SyndicationResourceLoadSettings
{
RetrievalLimit = numberOfItems
};
var feed = GenericSyndicationFeed.Create(new Uri(feedUrl), settings);
if (feed.Resource is RssFeed)
{
return(ReadRssFeed((RssFeed)feed.Resource));
}
if (feed.Resource is AtomFeed)
{
return(ReadAtomFeed((AtomFeed)feed.Resource));
}
throw new InvalidOperationException("Error Feed no soportado");
}
/// <summary>
/// Initializes the syndication extension using the supplied <see cref="IXPathNavigable"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <b>IXPathNavigable</b> used to load this <see cref="AtomPublishingControlSyndicationExtension"/>.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="AtomPublishingControlSyndicationExtension"/> was able to be initialized using the supplied <paramref name="source"/>; otherwise <b>false</b>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(IXPathNavigable source, SyndicationResourceLoadSettings settings)
{
Guard.ArgumentNotNull(source, "source");
XPathNavigator navigator = source.CreateNavigator();;
bool wasLoaded;
if (settings != null)
{
wasLoaded = Context.Load(navigator, CreateNamespaceManager(navigator), settings);
}
else
{
wasLoaded = Context.Load(navigator, CreateNamespaceManager(navigator));
}
SyndicationExtensionLoadedEventArgs args = new SyndicationExtensionLoadedEventArgs(source, this);
this.OnExtensionLoaded(args);
return(wasLoaded);
}
/// <summary>
/// Loads the syndication resource from the supplied <see cref="Uri"/> using the specified <see cref="ICredentials">credentials</see>, <see cref="IWebProxy">proxy</see> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that points to the location of the web resource used to load the syndication resource.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="AtomEntry"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// <para>
/// <list type="bullet">
/// <item>
/// <description>
/// If <paramref name="settings"/> has a <see cref="SyndicationResourceLoadSettings.CharacterEncoding">character encoding</see> of <see cref="System.Text.Encoding.UTF8"/>
/// the character encoding of the <paramref name="source"/> will be attempt to be determined automatically, otherwise the specified character encoding will be used.
/// If automatic detection fails, a character encoding of <see cref="System.Text.Encoding.UTF8"/> is used by default.
/// </description>
/// </item>
/// <item>
/// <description>
/// After the load operation has successfully completed, the <see cref="AtomEntry.Loaded"/> event will be raised.
/// </description>
/// </item>
/// </list>
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the entry remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the entry remains empty.</exception>
public new void Load(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Load syndication resource using base entry implementation
//------------------------------------------------------------
base.Load(source, options, settings);
//------------------------------------------------------------
// Extract member resource information from extensions
//------------------------------------------------------------
AtomPublishingEditedSyndicationExtension editedExtension = this.FindExtension(AtomPublishingEditedSyndicationExtension.MatchByType) as AtomPublishingEditedSyndicationExtension;
if (editedExtension != null)
{
this.EditedOn = editedExtension.Context.EditedOn;
}
AtomPublishingControlSyndicationExtension controlExtension = this.FindExtension(AtomPublishingControlSyndicationExtension.MatchByType) as AtomPublishingControlSyndicationExtension;
if (controlExtension != null)
{
this.IsDraft = controlExtension.Context.IsDraft;
}
}
/// <summary>
/// Loads this <see cref="RssFeed"/> instance asynchronously using the specified <see cref="Uri"/>, <see cref="SyndicationResourceLoadSettings"/>, <see cref="ICredentials"/>, and <see cref="IWebProxy"/>.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="RssFeed"/> instance. This value can be <b>null</b>.</param>
/// <param name="credentials">
/// A <see cref="ICredentials"/> that provides the proper set of credentials to the <paramref name="source"/> when required. This value can be <b>null</b>.
/// </param>
/// <param name="proxy">
/// A <see cref="IWebProxy"/> that provides proxy access to the <paramref name="source"/> when required. This value can be <b>null</b>.
/// </param>
/// <param name="userToken">A user-defined object that is passed to the method invoked when the asynchronous operation completes.</param>
/// <remarks>
/// <para>
/// To receive notification when the operation has completed or the operation has been canceled, add an event handler to the <see cref="Loaded"/> event.
/// You can cancel a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> operation by calling the <see cref="LoadAsyncCancel()"/> method.
/// </para>
/// <para>
/// After calling <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/>,
/// you must wait for the load operation to complete before attempting to load the syndication resource using the <see cref="LoadAsync(Uri, Object)"/> method.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="InvalidOperationException">This <see cref="RssFeed"/> has a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> call in progress.</exception>
public void LoadAsync(Uri source, SyndicationResourceLoadSettings settings, ICredentials credentials, IWebProxy proxy, Object userToken)
{
//------------------------------------------------------------
// Create instance using supplied parameter and specified settings
//------------------------------------------------------------
this.LoadAsync(source, settings, new WebRequestOptions(credentials, proxy), userToken);
}
/// <summary>
/// Loads the syndication resource from the supplied <see cref="Uri"/> using the specified <see cref="ICredentials">credentials</see>, <see cref="IWebProxy">proxy</see> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that points to the location of the web resource used to load the syndication resource.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="GenericSyndicationFeed"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// <para>
/// <list type="bullet">
/// <item>
/// <description>
/// If <paramref name="settings"/> has a <see cref="SyndicationResourceLoadSettings.CharacterEncoding">character encoding</see> of <see cref="System.Text.Encoding.UTF8"/>
/// the character encoding of the <paramref name="source"/> will be attempt to be determined automatically, otherwise the specified character encoding will be used.
/// If automatic detection fails, a character encoding of <see cref="System.Text.Encoding.UTF8"/> is used by default.
/// </description>
/// </item>
/// <item>
/// <description>
/// After the load operation has successfully completed, the <see cref="GenericSyndicationFeed.Loaded"/> event will be raised.
/// </description>
/// </item>
/// </list>
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to a supported syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception>
public void Load(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
XPathNavigator navigator = null;
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
//------------------------------------------------------------
// Use default settings if none specified by the caller
//------------------------------------------------------------
if (settings == null)
{
settings = new SyndicationResourceLoadSettings();
}
//------------------------------------------------------------
// Initialize XPathNavigator for supplied Uri, credentials, and proxy
//------------------------------------------------------------
if (settings.CharacterEncoding == System.Text.Encoding.UTF8)
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, null);
}
else
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, settings.CharacterEncoding);
}
//------------------------------------------------------------
// Load syndication resource using the framework adapters
//------------------------------------------------------------
this.Load(navigator, settings, new SyndicationResourceLoadedEventArgs(navigator, source, options));
}
/// <summary>
/// Loads the syndication resource from the supplied <see cref="Uri"/> using the specified <see cref="ICredentials">credentials</see>, <see cref="IWebProxy">proxy</see> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that points to the location of the web resource used to load the syndication resource.</param>
/// <param name="credentials">
/// A <see cref="ICredentials"/> that provides the proper set of credentials to the <paramref name="source"/> resource when required. This value can be <b>null</b>.
/// </param>
/// <param name="proxy">
/// A <see cref="IWebProxy"/> that provides proxy access to the <paramref name="source"/> resource when required. This value can be <b>null</b>.
/// </param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="GenericSyndicationFeed"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// <para>
/// <list type="bullet">
/// <item>
/// <description>
/// If <paramref name="credentials"/> is <b>null</b>, request is made using the default application credentials.
/// </description>
/// </item>
/// <item>
/// <description>
/// If <paramref name="proxy"/> is <b>null</b>, request is made using the <see cref="WebRequest"/> default proxy settings.
/// </description>
/// </item>
/// <item>
/// <description>
/// If <paramref name="settings"/> has a <see cref="SyndicationResourceLoadSettings.CharacterEncoding">character encoding</see> of <see cref="System.Text.Encoding.UTF8"/>
/// the character encoding of the <paramref name="source"/> will be attempt to be determined automatically, otherwise the specified character encoding will be used.
/// If automatic detection fails, a character encoding of <see cref="System.Text.Encoding.UTF8"/> is used by default.
/// </description>
/// </item>
/// <item>
/// <description>
/// After the load operation has successfully completed, the <see cref="GenericSyndicationFeed.Loaded"/> event will be raised.
/// </description>
/// </item>
/// </list>
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to a supported syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception>
public void Load(Uri source, ICredentials credentials, IWebProxy proxy, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Load syndication resource using specified settings
//------------------------------------------------------------
this.Load(source, new WebRequestOptions(credentials, proxy), settings);
}
/// <summary>
/// Loads this <see cref="BlogMLAuthor"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="BlogMLAuthor"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="BlogMLAuthor"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract common attributes information
//------------------------------------------------------------
if (BlogMLUtility.FillCommonObject(this, source, settings))
{
wasLoaded = true;
}
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
if(source.HasAttributes)
{
string emailAttribute = source.GetAttribute("email", String.Empty);
if (!String.IsNullOrEmpty(emailAttribute))
{
this.EmailAddress = emailAttribute;
wasLoaded = true;
}
}
//------------------------------------------------------------
// Attempt to extract syndication extension information
//------------------------------------------------------------
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return wasLoaded;
}
/// <summary>
/// Modifies the <see cref="AtomEntry"/> to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="entry">The <see cref="AtomEntry"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents an Atom 0.3 element.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillEntry(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(entry, "entry");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to fill syndication resource
//------------------------------------------------------------
AtomUtility.FillCommonObjectAttributes(entry, source);
XPathNavigator idNavigator = source.SelectSingleNode("atom:id", manager);
XPathNavigator titleNavigator = source.SelectSingleNode("atom:title", manager);
XPathNavigator modifiedNavigator = source.SelectSingleNode("atom:modified", manager);
if (idNavigator != null)
{
entry.Id = new AtomId();
entry.Id.Load(idNavigator, settings);
}
if (titleNavigator != null)
{
entry.Title = Atom03SyndicationResourceAdapter.CreateTextContent(titleNavigator, manager, settings);
}
if (modifiedNavigator != null)
{
DateTime updatedOn;
if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(modifiedNavigator.Value, out updatedOn))
{
entry.UpdatedOn = updatedOn;
}
}
Atom03SyndicationResourceAdapter.FillEntryOptionals(entry, source, manager, settings);
Atom03SyndicationResourceAdapter.FillEntryCollections(entry, source, manager, settings);
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(entry, manager);
}
/// <summary>
/// Creates a <see cref="AtomPersonConstruct"/> using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <returns>A <see cref="AtomPersonConstruct"/> instance initialized using the supplied <paramref name="source"/>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a Atom 0.3 Person construct.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static AtomPersonConstruct CreatePerson(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
AtomPersonConstruct person = new AtomPersonConstruct();
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract common attributes information
//------------------------------------------------------------
AtomUtility.FillCommonObjectAttributes(person, source);
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNavigator nameNavigator = source.SelectSingleNode("atom:name", manager);
XPathNavigator urlNavigator = source.SelectSingleNode("atom:url", manager);
XPathNavigator emailNavigator = source.SelectSingleNode("atom:email", manager);
if (nameNavigator != null)
{
person.Name = nameNavigator.Value;
}
if (urlNavigator != null)
{
Uri uri;
if (Uri.TryCreate(urlNavigator.Value, UriKind.RelativeOrAbsolute, out uri))
{
person.Uri = uri;
}
}
if (emailNavigator != null)
{
person.EmailAddress = emailNavigator.Value;
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(person, manager);
return person;
}
/// <summary>
/// Modifies the <see cref="AtomEntry"/> collection entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="entry">The <see cref="AtomEntry"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents an Atom 0.3 element.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillEntryCollections(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(entry, "entry");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNodeIterator authorIterator = source.Select("atom:author", manager);
XPathNodeIterator contributorIterator = source.Select("atom:contributor", manager);
XPathNodeIterator linkIterator = source.Select("atom:link", manager);
if (authorIterator != null && authorIterator.Count > 0)
{
while (authorIterator.MoveNext())
{
AtomPersonConstruct author = Atom03SyndicationResourceAdapter.CreatePerson(authorIterator.Current, manager, settings);
entry.Authors.Add(author);
}
}
if (contributorIterator != null && contributorIterator.Count > 0)
{
while (contributorIterator.MoveNext())
{
AtomPersonConstruct contributor = Atom03SyndicationResourceAdapter.CreatePerson(contributorIterator.Current, manager, settings);
entry.Contributors.Add(contributor);
}
}
if (linkIterator != null && linkIterator.Count > 0)
{
while (linkIterator.MoveNext())
{
AtomLink link = new AtomLink();
if (link.Load(linkIterator.Current, settings))
{
entry.Links.Add(link);
}
}
}
}
/// <summary>
/// Loads the optional RSS Profile elements of this <see cref="RssChannel"/> using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="RssChannel"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="RssChannel"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
private bool LoadProfile(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNodeIterator atomLinkIterator = source.Select("atom:link", manager);
if (atomLinkIterator != null && atomLinkIterator.Count > 0)
{
while (atomLinkIterator.MoveNext())
{
if (atomLinkIterator.Current.HasAttributes)
{
string relAttribute = atomLinkIterator.Current.GetAttribute("rel", String.Empty);
if (String.Compare(relAttribute, "self", StringComparison.OrdinalIgnoreCase) == 0)
{
string hrefAttribute = atomLinkIterator.Current.GetAttribute("href", String.Empty);
if (!String.IsNullOrEmpty(hrefAttribute))
{
Uri atomLink;
if (Uri.TryCreate(hrefAttribute, UriKind.RelativeOrAbsolute, out atomLink))
{
this.SelfLink = atomLink;
wasLoaded = true;
}
}
break;
}
}
}
}
return wasLoaded;
}
/// <summary>
/// Loads the optional elements of this <see cref="RssChannel"/> using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="RssChannel"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="RssChannel"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
private bool LoadOptionals(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNavigator cloudNavigator = source.SelectSingleNode("cloud", manager);
XPathNavigator copyrightNavigator = source.SelectSingleNode("copyright", manager);
XPathNavigator generatorNavigator = source.SelectSingleNode("generator", manager);
XPathNavigator imageNavigator = source.SelectSingleNode("image", manager);
XPathNavigator languageNavigator = source.SelectSingleNode("language", manager);
XPathNavigator lastBuildDateNavigator = source.SelectSingleNode("lastBuildDate", manager);
XPathNavigator managingEditorNavigator = source.SelectSingleNode("managingEditor", manager);
XPathNavigator publicationNavigator = source.SelectSingleNode("pubDate", manager);
XPathNavigator ratingNavigator = source.SelectSingleNode("rating", manager);
XPathNavigator textInputNavigator = source.SelectSingleNode("textInput", manager);
XPathNavigator timeToLiveNavigator = source.SelectSingleNode("ttl", manager);
XPathNavigator webMasterNavigator = source.SelectSingleNode("webMaster", manager);
if (cloudNavigator != null)
{
RssCloud cloud = new RssCloud();
if (cloud.Load(cloudNavigator, settings))
{
this.Cloud = cloud;
wasLoaded = true;
}
}
if (copyrightNavigator != null)
{
this.Copyright = copyrightNavigator.Value;
wasLoaded = true;
}
if (generatorNavigator != null)
{
this.Generator = generatorNavigator.Value;
wasLoaded = true;
}
if (imageNavigator != null)
{
RssImage image = new RssImage();
if (image.Load(imageNavigator, settings))
{
this.Image = image;
wasLoaded = true;
}
}
if (languageNavigator != null && !String.IsNullOrEmpty(languageNavigator.Value))
{
try
{
CultureInfo language = new CultureInfo(languageNavigator.Value);
this.Language = language;
wasLoaded = true;
}
catch (ArgumentException)
{
System.Diagnostics.Trace.TraceWarning("RssChannel unable to determine CultureInfo with a name of {0}.", languageNavigator.Value);
}
}
if (lastBuildDateNavigator != null)
{
DateTime lastBuildDate;
if (SyndicationDateTimeUtility.TryParseRfc822DateTime(lastBuildDateNavigator.Value, out lastBuildDate))
{
this.LastBuildDate = lastBuildDate;
wasLoaded = true;
}
}
if (managingEditorNavigator != null)
{
this.ManagingEditor = managingEditorNavigator.Value;
wasLoaded = true;
}
if (publicationNavigator != null)
{
DateTime publicationDate;
if (SyndicationDateTimeUtility.TryParseRfc822DateTime(publicationNavigator.Value, out publicationDate))
{
this.PublicationDate = publicationDate;
wasLoaded = true;
}
}
if (ratingNavigator != null)
{
this.Rating = ratingNavigator.Value;
wasLoaded = true;
}
if (textInputNavigator != null)
{
RssTextInput textInput = new RssTextInput();
if (textInput.Load(textInputNavigator, settings))
{
this.TextInput = textInput;
wasLoaded = true;
}
}
if (timeToLiveNavigator != null)
{
int timeToLive;
if (Int32.TryParse(timeToLiveNavigator.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out timeToLive))
{
this.TimeToLive = timeToLive;
wasLoaded = true;
}
}
if (webMasterNavigator != null)
{
this.Webmaster = webMasterNavigator.Value;
wasLoaded = true;
}
return wasLoaded;
}
/// <summary>
/// Loads the collection elements of this <see cref="RssChannel"/> using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="RssChannel"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// <para>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="RssChannel"/>.
/// </para>
/// <para>
/// The number of <see cref="RssChannel.Items"/> that are loaded is limited based on the <see cref="SyndicationResourceLoadSettings.RetrievalLimit"/>.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private bool LoadCollections(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNodeIterator categoryIterator = source.Select("category", manager);
XPathNodeIterator skipDaysIterator = source.Select("skipDays/day", manager);
XPathNodeIterator skipHoursIterator = source.Select("skipHours/hour", manager);
XPathNodeIterator itemIterator = source.Select("item", manager);
if (categoryIterator != null && categoryIterator.Count > 0)
{
while (categoryIterator.MoveNext())
{
RssCategory category = new RssCategory();
if (category.Load(categoryIterator.Current, settings))
{
this.Categories.Add(category);
wasLoaded = true;
}
}
}
if (skipDaysIterator != null && skipDaysIterator.Count > 0)
{
while (skipDaysIterator.MoveNext())
{
if (!String.IsNullOrEmpty(skipDaysIterator.Current.Value))
{
try
{
DayOfWeek day = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), skipDaysIterator.Current.Value, true);
if (!this.SkipDays.Contains(day))
{
this.SkipDays.Add(day);
wasLoaded = true;
}
}
catch (ArgumentException)
{
System.Diagnostics.Trace.TraceWarning("RssChannel unable to determine DayOfWeek with a name of {0}.", skipDaysIterator.Current.Value);
}
}
}
}
if (skipHoursIterator != null && skipHoursIterator.Count > 0)
{
while (skipHoursIterator.MoveNext())
{
int hour;
if (Int32.TryParse(skipHoursIterator.Current.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out hour))
{
if (!this.SkipHours.Contains(hour) && (hour >= 0 && hour <= 23))
{
this.SkipHours.Add(hour);
wasLoaded = true;
}
else
{
System.Diagnostics.Trace.TraceWarning("RssChannel unable to add duplicate or out-of-range skip hour with a value of {0}.", hour);
}
}
}
}
if (itemIterator != null && itemIterator.Count > 0)
{
int counter = 0;
while (itemIterator.MoveNext())
{
RssItem item = new RssItem();
counter++;
if (item.Load(itemIterator.Current, settings))
{
if (settings.RetrievalLimit != 0 && counter > settings.RetrievalLimit)
{
break;
}
((Collection<RssItem>)this.Items).Add(item);
wasLoaded = true;
}
}
}
return wasLoaded;
}
//============================================================
// PUBLIC/PRIVATE/PROTECTED MEMBERS
//============================================================
#region PRIVATE/PROTECTED/PUBLIC MEMBERS
#endregion
//============================================================
// CONSTRUCTORS
//============================================================
#region Rss090SyndicationResourceAdapter(XPathNavigator navigator, SyndicationResourceLoadSettings settings)
/// <summary>
/// Initializes a new instance of the <see cref="Rss090SyndicationResourceAdapter"/> class using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="navigator">A read-only <see cref="XPathNavigator"/> object for navigating through the syndication feed information.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="RssFeed"/>.</param>
/// <remarks>
/// This class expects the supplied <paramref name="navigator"/> to be positioned on the XML element that represents a <see cref="RssFeed"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public Rss090SyndicationResourceAdapter(XPathNavigator navigator, SyndicationResourceLoadSettings settings) : base(navigator, settings)
{
//------------------------------------------------------------
// Initialization and argument validation handled by base class
//------------------------------------------------------------
}
/// <summary>
/// Modifies the <see cref="AtomEntry"/> optional entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="entry">The <see cref="AtomEntry"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomEntry"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillEntryOptionals(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(entry, "entry");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNavigator contentNavigator = source.SelectSingleNode("atom:content", manager);
XPathNavigator publishedNavigator = source.SelectSingleNode("atom:published", manager);
XPathNavigator rightsNavigator = source.SelectSingleNode("atom:rights", manager);
XPathNavigator sourceNavigator = source.SelectSingleNode("atom:source", manager);
XPathNavigator summaryNavigator = source.SelectSingleNode("atom:summary", manager);
if (contentNavigator != null)
{
entry.Content = new AtomContent();
entry.Content.Load(contentNavigator, settings);
}
if (publishedNavigator != null)
{
DateTime publishedOn;
if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(publishedNavigator.Value, out publishedOn))
{
entry.PublishedOn = publishedOn;
}
}
if (rightsNavigator != null)
{
entry.Rights = new AtomTextConstruct();
entry.Rights.Load(rightsNavigator, settings);
}
if (sourceNavigator != null)
{
entry.Source = new AtomSource();
entry.Source.Load(sourceNavigator, settings);
}
if (summaryNavigator != null)
{
entry.Summary = new AtomTextConstruct();
entry.Summary.Load(summaryNavigator, settings);
}
}
/// <summary>
/// Loads this <see cref="RssFeed"/> instance asynchronously using the specified <see cref="Uri"/>, <see cref="SyndicationResourceLoadSettings"/>, <see cref="ICredentials"/>, and <see cref="IWebProxy"/>.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="RssFeed"/> instance. This value can be <b>null</b>.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="userToken">A user-defined object that is passed to the method invoked when the asynchronous operation completes.</param>
/// <remarks>
/// <para>
/// To receive notification when the operation has completed or the operation has been canceled, add an event handler to the <see cref="Loaded"/> event.
/// You can cancel a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> operation by calling the <see cref="LoadAsyncCancel()"/> method.
/// </para>
/// <para>
/// After calling <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/>,
/// you must wait for the load operation to complete before attempting to load the syndication resource using the <see cref="LoadAsync(Uri, Object)"/> method.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="InvalidOperationException">This <see cref="RssFeed"/> has a <see cref="LoadAsync(Uri, SyndicationResourceLoadSettings, ICredentials, IWebProxy, Object)"/> call in progress.</exception>
public void LoadAsync(Uri source, SyndicationResourceLoadSettings settings, WebRequestOptions options, Object userToken)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
//------------------------------------------------------------
// Use default settings if none specified by the caller
//------------------------------------------------------------
if (settings == null)
{
settings = new SyndicationResourceLoadSettings();
}
//------------------------------------------------------------
// Validate syndication resource state
//------------------------------------------------------------
if (this.LoadOperationInProgress)
{
throw new InvalidOperationException();
}
//------------------------------------------------------------
// Indicate that a load operation is in progress
//------------------------------------------------------------
this.LoadOperationInProgress = true;
//------------------------------------------------------------
// Reset the asynchronous load operation cancelled indicator
//------------------------------------------------------------
this.AsyncLoadHasBeenCancelled = false;
//------------------------------------------------------------
// Build HTTP web request used to retrieve the syndication resource
//------------------------------------------------------------
asyncHttpWebRequest = SyndicationEncodingUtility.CreateWebRequest(source, options);
asyncHttpWebRequest.Timeout = Convert.ToInt32(settings.Timeout.TotalMilliseconds, System.Globalization.NumberFormatInfo.InvariantInfo);
//------------------------------------------------------------
// Get the async response to the web request
//------------------------------------------------------------
object[] state = new object[6] { asyncHttpWebRequest, this, source, settings, options, userToken };
IAsyncResult result = asyncHttpWebRequest.BeginGetResponse(new AsyncCallback(AsyncLoadCallback), state);
//------------------------------------------------------------
// Register the timeout callback
//------------------------------------------------------------
ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(AsyncTimeoutCallback), state, settings.Timeout, true);
}
/// <summary>
/// Modifies the <see cref="AtomFeed"/> collection entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="feed">The <see cref="AtomFeed"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomFeed"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="feed"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillFeedCollections(AtomFeed feed, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(feed, "feed");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNodeIterator authorIterator = source.Select("atom:author", manager);
XPathNodeIterator contributorIterator = source.Select("atom:contributor", manager);
XPathNodeIterator linkIterator = source.Select("atom:link", manager);
XPathNodeIterator entryIterator = source.Select("atom:entry", manager);
if (authorIterator != null && authorIterator.Count > 0)
{
while (authorIterator.MoveNext())
{
AtomPersonConstruct author = Atom03SyndicationResourceAdapter.CreatePerson(authorIterator.Current, manager, settings);
feed.Authors.Add(author);
}
}
if (contributorIterator != null && contributorIterator.Count > 0)
{
while (contributorIterator.MoveNext())
{
AtomPersonConstruct contributor = Atom03SyndicationResourceAdapter.CreatePerson(contributorIterator.Current, manager, settings);
feed.Contributors.Add(contributor);
}
}
if (entryIterator != null && entryIterator.Count > 0)
{
int counter = 0;
while (entryIterator.MoveNext())
{
AtomEntry entry = new AtomEntry();
counter++;
Atom03SyndicationResourceAdapter.FillEntry(entry, entryIterator.Current, manager, settings);
if (settings.RetrievalLimit != 0 && counter > settings.RetrievalLimit)
{
break;
}
((Collection<AtomEntry>)feed.Entries).Add(entry);
}
}
if (linkIterator != null && linkIterator.Count > 0)
{
while (linkIterator.MoveNext())
{
AtomLink link = new AtomLink();
if (link.Load(linkIterator.Current, settings))
{
feed.Links.Add(link);
}
}
}
}
/// <summary>
/// Loads this <see cref="RssImage"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="RssImage"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="RssImage"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
wasLoaded = this.Load(source);
//------------------------------------------------------------
// Attempt to extract syndication extension information
//------------------------------------------------------------
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return wasLoaded;
}
/// <summary>
/// Loads this <see cref="ApmlApplication"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="ApmlApplication"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlApplication"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Initialize XML namespace resolver
//------------------------------------------------------------
XmlNamespaceManager manager = BlogMLUtility.CreateNamespaceManager(source.NameTable);
//------------------------------------------------------------
// Attempt to extract common attributes information
//------------------------------------------------------------
if (BlogMLUtility.FillCommonObject(this, source, settings))
{
wasLoaded = true;
}
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
if(source.HasAttributes)
{
string userNameAttribute = source.GetAttribute("user-name", String.Empty);
string userEmailAttribute = source.GetAttribute("user-email", String.Empty);
string userUrlAttribute = source.GetAttribute("user-url", String.Empty);
if (!String.IsNullOrEmpty(userNameAttribute))
{
this.UserName = userNameAttribute;
wasLoaded = true;
}
if (!String.IsNullOrEmpty(userEmailAttribute))
{
this.UserEmailAddress = userEmailAttribute;
wasLoaded = true;
}
if (!String.IsNullOrEmpty(userUrlAttribute))
{
Uri url;
if (Uri.TryCreate(userUrlAttribute, UriKind.RelativeOrAbsolute, out url))
{
this.UserUrl = url;
wasLoaded = true;
}
}
}
if (source.HasChildren)
{
XPathNavigator contentNavigator = source.SelectSingleNode("blog:content", manager);
if (contentNavigator != null)
{
BlogMLTextConstruct content = new BlogMLTextConstruct();
if (content.Load(contentNavigator))
{
this.Content = content;
wasLoaded = true;
}
}
}
//------------------------------------------------------------
// Attempt to extract syndication extension information
//------------------------------------------------------------
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return wasLoaded;
}
/// <summary>
/// Creates a <see cref="AtomGenerator"/> using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <returns>A <see cref="AtomGenerator"/> instance initialized using the supplied <paramref name="source"/>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a Atom 0.3 generator element.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static AtomGenerator CreateGenerator(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
AtomGenerator generator = new AtomGenerator();
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract common attributes information
//------------------------------------------------------------
AtomUtility.FillCommonObjectAttributes(generator, source);
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
if(source.HasAttributes)
{
string urlAttribute = source.GetAttribute("url", String.Empty);
string versionAttribute = source.GetAttribute("version", String.Empty);
if (!String.IsNullOrEmpty(urlAttribute))
{
Uri uri;
if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out uri))
{
generator.Uri = uri;
}
}
if (!String.IsNullOrEmpty(versionAttribute))
{
generator.Version = versionAttribute;
}
}
if (!String.IsNullOrEmpty(source.Value))
{
generator.Content = source.Value;
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(generator, manager);
return generator;
}
/// <summary>
/// Initializes the supplied <see cref="RssImage"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>.
/// </summary>
/// <param name="image">The <see cref="RssImage"/> to be filled.</param>
/// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the image XML data.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param>
/// <exception cref="ArgumentNullException">The <paramref name="image"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillImage(RssImage image, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(image, "image");
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract image information
//------------------------------------------------------------
XPathNavigator linkNavigator = navigator.SelectSingleNode("rss:link", manager);
XPathNavigator titleNavigator = navigator.SelectSingleNode("rss:title", manager);
XPathNavigator urlNavigator = navigator.SelectSingleNode("rss:url", manager);
if (linkNavigator != null)
{
Uri link;
if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link))
{
image.Link = link;
}
}
if (titleNavigator != null)
{
if (!String.IsNullOrEmpty(titleNavigator.Value))
{
image.Title = titleNavigator.Value;
}
}
if (urlNavigator != null)
{
Uri url;
if (Uri.TryCreate(urlNavigator.Value, UriKind.RelativeOrAbsolute, out url))
{
image.Url = url;
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings);
adapter.Fill(image);
}
/// <summary>
/// Creates a <see cref="AtomTextConstruct"/> using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <returns>A <see cref="AtomTextConstruct"/> instance initialized using the supplied <paramref name="source"/>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a Atom 0.3 Content construct.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static AtomTextConstruct CreateTextContent(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
AtomTextConstruct content = new AtomTextConstruct();
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract common attributes information
//------------------------------------------------------------
AtomUtility.FillCommonObjectAttributes(content, source);
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
if (source.HasAttributes)
{
string modeAttribute = source.GetAttribute("mode", String.Empty);
if (!String.IsNullOrEmpty(modeAttribute))
{
if (String.Compare(modeAttribute, "base64", StringComparison.OrdinalIgnoreCase) == 0)
{
content.TextType = AtomTextConstructType.Text;
}
else if (String.Compare(modeAttribute, "escaped", StringComparison.OrdinalIgnoreCase) == 0)
{
content.TextType = AtomTextConstructType.Html;
}
else if (String.Compare(modeAttribute, "xml", StringComparison.OrdinalIgnoreCase) == 0)
{
content.TextType = AtomTextConstructType.Xhtml;
}
else
{
content.TextType = AtomTextConstructType.Text;
}
}
}
if (content.TextType == AtomTextConstructType.Xhtml)
{
XPathNavigator xhtmlDivNavigator = source.SelectSingleNode("xhtml:div", manager);
if (xhtmlDivNavigator != null && !String.IsNullOrEmpty(xhtmlDivNavigator.Value))
{
content.Content = xhtmlDivNavigator.Value;
}
else if (!String.IsNullOrEmpty(source.Value))
{
content.Content = source.Value;
}
}
else if (!String.IsNullOrEmpty(source.Value))
{
content.Content = source.Value;
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(content, manager);
return content;
}
/// <summary>
/// Loads the syndication resource from the specified <see cref="XmlReader"/>.
/// </summary>
/// <param name="reader">The <b>XmlReader</b> used to load the syndication resource.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="RssFeed"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// After the load operation has successfully completed, the <see cref="RssFeed.Loaded"/> event will be raised.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="reader"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="reader"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception>
public void Load(XmlReader reader, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(reader, "reader");
//------------------------------------------------------------
// Use reader to create a IXPathNavigable to load from
//------------------------------------------------------------
this.Load(new XPathDocument(reader), settings);
}
/// <summary>
/// Loads the generic syndication feed using the specified <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="navigator">A read-only <see cref="XPathNavigator"/> object for navigating through the syndication resource information.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="GenericSyndicationFeed"/>.</param>
/// <param name="eventData">A <see cref="SyndicationResourceLoadedEventArgs"/> that contains the event data used when raising the <see cref="GenericSyndicationFeed.Loaded"/> event.</param>
/// <remarks>
/// After the load operation has successfully completed, the <see cref="GenericSyndicationFeed.Loaded"/> event is raised using the specified <paramref name="eventData"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="eventData"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="navigator"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
private void Load(XPathNavigator navigator, SyndicationResourceLoadSettings settings, SyndicationResourceLoadedEventArgs eventData)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(settings, "settings");
Guard.ArgumentNotNull(eventData, "eventData");
//------------------------------------------------------------
// Initialize generic feed based on syndication resource format
//------------------------------------------------------------
SyndicationResourceMetadata metadata = new SyndicationResourceMetadata(navigator);
if (metadata.Format == SyndicationContentFormat.Atom)
{
AtomFeed feed = new AtomFeed();
SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings);
adapter.Fill(feed, SyndicationContentFormat.Atom);
this.Parse(feed);
}
else if (metadata.Format == SyndicationContentFormat.Rss)
{
RssFeed feed = new RssFeed();
SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings);
adapter.Fill(feed, SyndicationContentFormat.Rss);
this.Parse(feed);
}
else if (metadata.Format == SyndicationContentFormat.Opml)
{
OpmlDocument opmlDoc = new OpmlDocument();
SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings);
adapter.Fill(opmlDoc, SyndicationContentFormat.Opml);
this.Parse(opmlDoc);
}
//------------------------------------------------------------
// Raise Loaded event to notify registered handlers of state change
//------------------------------------------------------------
this.OnFeedLoaded(eventData);
}
/// <summary>
/// Modifies the <see cref="AtomFeed"/> optional entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="feed">The <see cref="AtomFeed"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomFeed"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="feed"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillFeedOptionals(AtomFeed feed, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(feed, "feed");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNavigator generatorNavigator = source.SelectSingleNode("atom:generator", manager);
XPathNavigator iconNavigator = source.SelectSingleNode("atom:icon", manager);
XPathNavigator logoNavigator = source.SelectSingleNode("atom:logo", manager);
XPathNavigator rightsNavigator = source.SelectSingleNode("atom:rights", manager);
XPathNavigator subtitleNavigator = source.SelectSingleNode("atom:subtitle", manager);
if (generatorNavigator != null)
{
feed.Generator = new AtomGenerator();
feed.Generator.Load(generatorNavigator, settings);
}
if (iconNavigator != null)
{
feed.Icon = new AtomIcon();
feed.Icon.Load(iconNavigator, settings);
}
if (logoNavigator != null)
{
feed.Logo = new AtomLogo();
feed.Logo.Load(logoNavigator, settings);
}
if (rightsNavigator != null)
{
feed.Rights = new AtomTextConstruct();
feed.Rights.Load(rightsNavigator, settings);
}
if (subtitleNavigator != null)
{
feed.Subtitle = new AtomTextConstruct();
feed.Subtitle.Load(subtitleNavigator, settings);
}
}
/// <summary>
/// Modifies the <see cref="AtomEntry"/> optional entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="entry">The <see cref="AtomEntry"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents an Atom 0.3 element.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillEntryOptionals(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(entry, "entry");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNavigator contentNavigator = source.SelectSingleNode("atom:content", manager);
XPathNavigator createdNavigator = source.SelectSingleNode("atom:created", manager);
XPathNavigator summaryNavigator = source.SelectSingleNode("atom:summary", manager);
if (contentNavigator != null)
{
entry.Content = Atom03SyndicationResourceAdapter.CreateContent(contentNavigator, manager, settings);
}
if (createdNavigator != null)
{
DateTime publishedOn;
if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(createdNavigator.Value, out publishedOn))
{
entry.PublishedOn = publishedOn;
}
}
if (summaryNavigator != null)
{
entry.Summary = Atom03SyndicationResourceAdapter.CreateTextContent(summaryNavigator, manager, settings);
}
}
/// <summary>
/// Creates a new <see cref="GenericSyndicationFeed"/> instance using the specified <see cref="Uri"/> and <see cref="SyndicationResourceLoadSettings"/> object.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="GenericSyndicationFeed"/> instance. This value can be <b>null</b>.</param>
/// <returns>An <see cref="GenericSyndicationFeed"/> object loaded using the <paramref name="source"/> data.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
public static GenericSyndicationFeed Create(Uri source, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Create instance using supplied parameters and default settings
//------------------------------------------------------------
return GenericSyndicationFeed.Create(source, new WebRequestOptions(), settings);
}
/// <summary>
/// Modifies the <see cref="AtomFeed"/> optional entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="feed">The <see cref="AtomFeed"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomFeed"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="feed"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillFeedOptionals(AtomFeed feed, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(feed, "feed");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNavigator generatorNavigator = source.SelectSingleNode("atom:generator", manager);
XPathNavigator copyrightNavigator = source.SelectSingleNode("atom:copyright", manager);
XPathNavigator taglineNavigator = source.SelectSingleNode("atom:tagline", manager);
if (generatorNavigator != null)
{
feed.Generator = Atom03SyndicationResourceAdapter.CreateGenerator(generatorNavigator, manager, settings);
}
if (copyrightNavigator != null)
{
feed.Rights = Atom03SyndicationResourceAdapter.CreateTextContent(copyrightNavigator, manager, settings);
}
if (taglineNavigator != null)
{
feed.Subtitle = Atom03SyndicationResourceAdapter.CreateTextContent(taglineNavigator, manager, settings);
}
}
/// <summary>
/// Creates a new <see cref="GenericSyndicationFeed"/> instance using the specified <see cref="Uri"/>, <see cref="ICredentials"/>, <see cref="IWebProxy"/>, and <see cref="SyndicationResourceLoadSettings"/> object.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
/// <param name="credentials">
/// A <see cref="ICredentials"/> that provides the proper set of credentials to the <paramref name="source"/> when required. This value can be <b>null</b>.
/// </param>
/// <param name="proxy">
/// A <see cref="IWebProxy"/> that provides proxy access to the <paramref name="source"/> when required. This value can be <b>null</b>.
/// </param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="GenericSyndicationFeed"/> instance. This value can be <b>null</b>.</param>
/// <returns>An <see cref="GenericSyndicationFeed"/> object loaded using the <paramref name="source"/> data.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
public static GenericSyndicationFeed Create(Uri source, ICredentials credentials, IWebProxy proxy, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Create new instance using supplied parameters
//------------------------------------------------------------
return GenericSyndicationFeed.Create(source, new WebRequestOptions(credentials, proxy), settings);
}
/// <summary>
/// Creates a new <see cref="GenericSyndicationFeed"/> instance using the specified <see cref="Uri"/>, <see cref="ICredentials"/>, <see cref="IWebProxy"/>, and <see cref="SyndicationResourceLoadSettings"/> object.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="GenericSyndicationFeed"/> instance. This value can be <b>null</b>.</param>
/// <returns>An <see cref="GenericSyndicationFeed"/> object loaded using the <paramref name="source"/> data.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
public static GenericSyndicationFeed Create(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
GenericSyndicationFeed syndicationResource = new GenericSyndicationFeed();
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
//------------------------------------------------------------
// Create new instance using supplied parameters
//------------------------------------------------------------
syndicationResource.Load(source, options, settings);
return syndicationResource;
}
/// <summary>
/// Loads the syndication resource from the specified <see cref="Stream"/>.
/// </summary>
/// <param name="stream">The <b>Stream</b> used to load the syndication resource.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="GenericSyndicationFeed"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// After the load operation has successfully completed, the <see cref="GenericSyndicationFeed.Loaded"/> event will be raised.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="stream"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="stream"/> data does not conform to a supported syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception>
public void Load(Stream stream, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(stream, "stream");
//------------------------------------------------------------
// Use stream to create a XPathNavigator to load from
//------------------------------------------------------------
XPathNavigator navigator = null;
if (settings != null)
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(stream, settings.CharacterEncoding);
}
else
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(stream);
}
//------------------------------------------------------------
// Load syndication resource using the framework adapters
//------------------------------------------------------------
this.Load(navigator, settings == null ? new SyndicationResourceLoadSettings() : settings, new SyndicationResourceLoadedEventArgs(navigator));
}
/// <summary>
/// Initializes the supplied <see cref="RssTextInput"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>.
/// </summary>
/// <param name="textInput">The <see cref="RssTextInput"/> to be filled.</param>
/// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the text input XML data.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param>
/// <exception cref="ArgumentNullException">The <paramref name="textInput"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillTextInput(RssTextInput textInput, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(textInput, "textInput");
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract text input information
//------------------------------------------------------------
XPathNavigator descriptionNavigator = navigator.SelectSingleNode("rss:description", manager);
XPathNavigator linkNavigator = navigator.SelectSingleNode("rss:link", manager);
XPathNavigator nameNavigator = navigator.SelectSingleNode("rss:name", manager);
XPathNavigator titleNavigator = navigator.SelectSingleNode("rss:title", manager);
if (descriptionNavigator != null)
{
if (!String.IsNullOrEmpty(descriptionNavigator.Value))
{
textInput.Description = descriptionNavigator.Value;
}
}
if (linkNavigator != null)
{
Uri link;
if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link))
{
textInput.Link = link;
}
}
if (nameNavigator != null)
{
if (!String.IsNullOrEmpty(nameNavigator.Value))
{
textInput.Name = nameNavigator.Value;
}
}
if (titleNavigator != null)
{
if (!String.IsNullOrEmpty(titleNavigator.Value))
{
textInput.Title = titleNavigator.Value;
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings);
adapter.Fill(textInput);
}
/// <summary>
/// Loads the syndication resource from the specified <see cref="Stream"/>.
/// </summary>
/// <param name="stream">The <b>Stream</b> used to load the syndication resource.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="RssFeed"/> instance. This value can be <b>null</b>.</param>
/// <remarks>
/// After the load operation has successfully completed, the <see cref="RssFeed.Loaded"/> event will be raised.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="stream"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="stream"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
/// <exception cref="XmlException">There is a load or parse error in the XML. In this case, the feed remains empty.</exception>
public void Load(Stream stream, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(stream, "stream");
//------------------------------------------------------------
// Use stream to create a XPathNavigator to load from
//------------------------------------------------------------
if (settings != null)
{
this.Load(SyndicationEncodingUtility.CreateSafeNavigator(stream, settings.CharacterEncoding), settings);
}
else
{
this.Load(SyndicationEncodingUtility.CreateSafeNavigator(stream), settings);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AtomPublishing10SyndicationResourceAdapter"/> class using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="navigator">A read-only <see cref="XPathNavigator"/> object for navigating through the syndication document information.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="AtomServiceDocument"/>.</param>
/// <remarks>
/// This class expects the supplied <paramref name="navigator"/> to be positioned on the XML element that represents a <see cref="AtomServiceDocument"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public AtomPublishing10SyndicationResourceAdapter(XPathNavigator navigator, SyndicationResourceLoadSettings settings) : base(navigator, settings)
{
}
/// <summary>
/// Loads this <see cref="RssChannel"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="RssChannel"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="RssChannel"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Create namespace resolver
//------------------------------------------------------------
XmlNamespaceManager manager = new XmlNamespaceManager(source.NameTable);
manager.AddNamespace("atom", "http://www.w3.org/2005/Atom");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNavigator descriptionNavigator = source.SelectSingleNode("description", manager);
XPathNavigator linkNavigator = source.SelectSingleNode("link", manager);
XPathNavigator titleNavigator = source.SelectSingleNode("title", manager);
//------------------------------------------------------------
// Load required channel information
//------------------------------------------------------------
if (descriptionNavigator != null && !String.IsNullOrEmpty(descriptionNavigator.Value))
{
this.Description = descriptionNavigator.Value;
wasLoaded = true;
}
if (linkNavigator != null)
{
Uri link;
if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link))
{
this.Link = link;
wasLoaded = true;
}
}
if (titleNavigator != null && !String.IsNullOrEmpty(titleNavigator.Value))
{
this.Title = titleNavigator.Value;
wasLoaded = true;
}
//------------------------------------------------------------
// Load optional channel information
//------------------------------------------------------------
if (this.LoadOptionals(source, manager, settings))
{
wasLoaded = true;
}
//------------------------------------------------------------
// Load channel collections information
//------------------------------------------------------------
if (this.LoadCollections(source, manager, settings))
{
wasLoaded = true;
}
//------------------------------------------------------------
// Load optional RSS Profile channel information
//------------------------------------------------------------
if (this.LoadProfile(source, manager, settings))
{
wasLoaded = true;
}
//------------------------------------------------------------
// Attempt to extract syndication extension information
//------------------------------------------------------------
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return wasLoaded;
}
