1. Web Design
  2. HTML/CSS

Wie man einen RSS-Feed mit ASP.NET bauen.

Scroll to top

German (Deutsch) translation by Wilhelm Wolf (you can also view the original English article)

Im Laufe dieses Tutorials werden wir prüfen, wie ein RSS-Feed mit den ASP.NET Rahmen. Mit einem RSS-feed für Ihre Website zu einer Notwendigkeit geworden in den letzten Jahren. Mit blogs oder news-sites werden Häufig aktualisiert, und mit der großen Menge von blogs und news-websites dort draußen, RSS erlaubt hat, die Leser zu halten mit neuen Inhalten, ohne gezwungen Sie zu besuchen. Sobald Sie dieses tutorial abgeschlossen haben, werden Sie wissen, wie man einen RSS-feed erstellen mit ASP.NET und wie zum Rendern von XML-Dokumenten auf ASP.NET Web-Seiten.


Schritt 0: das RSS-2.0-Einführung

RSS ist ein web-content-syndication-format. Es steht für "Really Simple Syndication" und ist in XML geschrieben. Alle RSS Dateien müssen konform zum XML-1.0-Spezifikation, veröffentlicht von der World Wide Web Consortium (W3C). Mit RSS ist es möglich zu verbreiten up-to-date web-Inhalte von einer Website zu tausenden von anderen auf der ganzen Welt. Zur Vereinfachung der Begriff, RSS-ermöglicht schnelles surfen für news und updates.

Die syntax-Regeln von RSS 2.0 sind einfach, aber streng. Hier ist ein einfacher RSS-Dokument:

1
<?xml version="1.0" encoding="utf-8" ?>
2
<rss version="2.0">
3
  <channel>
4
    <title>Your Website Name</title>
5
    <link>https://www.yourdomain.com</link>
6
    <description>Free RSS Tutorial</description>
7
    <item>
8
      <title>First Article</title>
9
      <link>http://www.yourdomain.com/article.aspx?ID=1</link>
10
      <description>The description of the first article.</description>
11
    </item>
12
    <item>
13
      <title>Second Article</title>
14
      <link>http://www.yourdomain.com/article.aspx?ID=2</link>
15
      <description>The description of the second article.</description>
16
    </item>
17
  </channel>
18
</rss>

Die erste Zeile im Dokument die XML-Deklaration - definiert die XML-version und die Zeichenkodierung im Dokument verwendet werden. In diesem Fall wird das Dokument entspricht der 1.0-Spezifikation von XML und verwendet die utf-8-Zeichensatz. Die nächste Zeile ist der RSS-Deklaration, die identifiziert, das ist in der Tat ein RSS-Dokument (genauer gesagt, eine RSS-version 2.0).

Die nächste Zeile enthält das - element. Dieses element wird verwendet, um zu beschreiben, den RSS-feed. Das - element hat drei erforderliche untergeordnete Elemente:

  • - Legt den Titel des Kanals (z.B. Ihre Website-name)
  • - Definiert den hyperlink, um den Kanal (z.B. http://www.yourdomain.com)
  • - Beschreibung des Kanals (z.B. Kostenloser RSS-Tutorial)

Jedes - element kann mit einem oder mehreren Elementen. Jedes - element definiert einen Artikel oder "story" in den RSS-feed.

Der - element erfordert drei child-Elemente:

  • - Legt den Titel der Nachricht (z.B. Erste Artikel)
  • - Definiert den hyperlink auf den Artikel (z.B. http://www.yourdomain.com/article.aspx?ID=1)
  • - Beschreibung des Elements (z.B. Die Beschreibung des ersten Artikels)

Bei der Anzeige in Firefox ist, das RSS-Dokument oben Aussehen sollte:

RSS document

Schritt 1: Erste Schritte

Um diesem tutorial zu Folgen, stellen Sie sich vor, Sie arbeiten als web-Entwickler, und bauen eine news-website, wo alle Nachrichten werden gespeichert in der Microsoft SQL Server-Datenbank. Insbesondere die Artikel werden in einer Tabelle namens News, die enthält die folgenden Felder:

  • ArticleID - eine auto-increment primary key integer-Feld eindeutig identifiziert jeden Artikel
  • Titel - vom Datentyp nvarchar(256), die Angabe des Titels des Artikels
  • Autor - ein nvarchar(50), der angibt, der Autor des Artikels
  • Beschreibung - ein vom Datentyp nvarchar(500), bietet eine eingehende Beschreibung des Artikels
  • DatePublished - ein datetime-Wert, der angibt, das Datum der Artikel veröffentlicht wurde

Beachten Sie, dass es möglicherweise andere Felder in der News-Tabelle, aber die oben aufgeführten sind die einzigen, die wir daran interessiert sind -- zumindest für die Zwecke der RSS-feed.

Wir verwenden Visual Studio, um beenden Sie das Beispiel. Wenn Sie nicht die volle version von VS können Sie schnappen Sie sich die Kostenlose Express Edition.


Schritt 2: Erstellen eines rss -.aspx-Seite

Unser Nächster Schritt ist die Erstellung einer ASP.NET Web-Seite (rss-Feeds.aspx) angezeigt wird eine Liste der aktuellsten Neuigkeiten, wie eine korrekt formatierte RSS 2.0-Dokument. Im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und klicken Sie dann auf Neues Element Hinzufügen. In thia Dialogfeld unter von Visual Studio installierte Vorlagen klicken Sie auf Web Form.

Add New Page

Im Feld Name geben Sie einen Namen für das neue Web-Seite (rss-Feeds.aspx), und klicken Sie dann auf Hinzufügen. Die neue ASP.NET web-Seite (rss-Feeds.aspx) erstellt und angezeigt, entsprechend.

Weil wir wollen, dass die rss.aspx-Seite zu erzeugen, XML-Ausgabe, die erste Sache, die wir tun müssen, ist entfernen Sie alle HTML-markup oder web-Steuerelemente auf der Seite, und legen Sie dann die ContentType-Eigenschaft @page-Direktive auf "text/xml".

Nach dem löschen alle HTML Tags aus rss.aspx-Seite, fügen Sie ein Repeater-Steuerelement in die Seite. Wir verwenden Repeater-Steuerelement zum Rendern RSS-Dokument auf rss.aspx-Seite.

Hier ist der source-Ansicht des rss.aspx-Seite, nachdem wir einige Veränderungen vorgenommen haben:

1
<%@ Page Language="C#" ContentType="text/xml" AutoEventWireup="true" CodeBehind="rss.aspx.cs" Inherits="NettutsTutorial2.rss" %>
2
3
<asp:Repeater ID="RepeaterRSS" runat="server">
4
</asp:Repeater>

Schritt 3: Einrichten Der Connection-String

Als Nächstes wollen wir-setup den connection-string der Datenquelle in der Web.config-Datei. Durch das speichern der Verbindungszeichenfolge Informationen, wir werden vermeiden, hart-code in der code-behind-Datei. Dies vereinfacht die Dinge, wenn die Verbindungszeichenfolge Informationen zu änderungen in der Zukunft. Legen Sie es in den - Abschnitt unter Konfiguration-element, etwa so:

1
<connectionStrings>
2
  <add name="ConnectionString" connectionString="Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\Nettuts.mdf;Integrated Security=True;User Instance=True"
3
   providerName="System.Data.SqlClient" />
4
 </connectionStrings>

Wir greifen auf diese Informationen aus dem code-behind-Datei später wenn wir wollen, dass Sie zum abrufen von Daten aus der Datenbank.


Schritt 4: Entfernen Sie ungültige Zeichen aus dem XML-Dokument

Einige Zeichen haben eine Besondere Bedeutung in XML haben. Wenn Sie ein Zeichen wie " < " in ein XML-element, es wird ein Fehler generiert, da der parser interpretiert es als Beginn eines neuen Elements. Um diesen Fehler zu vermeiden, ersetzen Sie die " < " - Zeichen mit seinen entity-Referenz (<).

Es gibt fünf vordefinierte entity-Referenzen in XML:

< < weniger als
> > größer als
& & kaufmännisches und-Zeichen
' ' Apostroph
" " Anführungszeichen

Um zu vermeiden, unseren RSS-feed ein Fehler erzeugt, müssen wir ändern alle ungültigen Zeichen in einem RSS-Dokument mit Ihren entity-Referenzen. Fügen Sie den folgenden code in das code-behind-Datei des rss.aspx-Seite (rss-Feeds.aspx.cs):

1
protected string RemoveIllegalCharacters(object input)
2
{
3
    // cast the input to a string
4
    string data = input.ToString();      
5
6
    // replace illegal characters in XML documents with their entity references
7
    data = data.Replace("&", "&amp;");
8
    data = data.Replace("\"", "&quot;");
9
    data = data.Replace("'", "&apos;");
10
    data = data.Replace("<", "&lt;");
11
    data = data.Replace(">", "&gt;");
12
13
    return data;
14
}

Die RemoveIllegalCharacters() Funktion führt ein paar einfache string-Ersetzungen, wenn nötig. Wir rufen diese Funktion über das rss.aspx-Seite in Kürze.


Schritt 5: Abrufen von Daten aus der Datenbank

Fügen Sie den folgenden code in die Page_Load-Ereignishandler:

1
protected void Page_Load(object sender, EventArgs e)
2
{
3
    // Get connection string from the web.config file
4
    string connString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
5
6
    // Create SqlConnection object
7
    SqlConnection sqlConn = new SqlConnection();
8
    sqlConn.ConnectionString = connString;
9
10
    // SQL query to retrieve data from database
11
    string sqlQuery = "SELECT TOP 10 ArticleID, Title, Author, Description, DatePublished FROM News ORDER BY DatePublished DESC";
12
13
    // Create SqlCommand object
14
    SqlCommand cmd = new SqlCommand();
15
    cmd.Connection = sqlConn;
16
    cmd.CommandType = CommandType.Text;
17
    cmd.CommandText = sqlQuery;
18
19
    // open connection and then binding data into RepeaterRSS control
20
    sqlConn.Open();
21
    RepeaterRSS.DataSource = cmd.ExecuteReader();
22
    RepeaterRSS.DataBind();
23
    sqlConn.Close();
24
}

Der obige code abzurufen, die zehn aktuellsten Neuigkeiten aus Ihrer Datenbank. Es wird dann binden Sie ein Repeater-Steuerelement (RepeaterRSS), wenn die Seite geladen wird.


Schritt 6: Rendern Von Daten

Dies ist unser letzter Schritt. Es ist Zeit zum Rendern von Elementen aus der News-Tabelle in einem entsprechenden RSS 2.0 syndication-Datei. Der einfachste und Schnellste Weg, um die Daten der Datenbank als XML ist die Verwendung eines Repeater-Steuerelements (RepeaterRSS). Insbesondere die Repeater-display das , , und Website-bezogene element-tags in seine HeaderTemplate und FooterTemplate Vorlagen, und die - Elemente in der ItemTemplate-Vorlage. Vergessen Sie nicht, rufen die Helfer RemoveIllegalCharacters () - Funktion zu ersetzen, die unerwünschte Zeichen aus dem string ausgegeben.

Im folgenden ist der HTML-Teil unserer ASP.NET Web-Seite (rss-Feeds.aspx):

1
<%@ Page Language="C#" ContentType="text/xml" AutoEventWireup="true" CodeBehind="rss.aspx.cs" Inherits="NettutsTutorial2.rss" %>
2
3
<asp:Repeater ID="RepeaterRSS" runat="server">
4
        <HeaderTemplate>
5
           <rss version="2.0">
6
                <channel>
7
                    <title>Name of the Website</title>
8
                    <link>http://www.yourdomain.com</link>
9
                    <description>
10
                    Short description of the website.
11
                    </description>
12
        </HeaderTemplate>
13
        <ItemTemplate>
14
            <item>
15
                <title><%# RemoveIllegalCharacters(DataBinder.Eval(Container.DataItem, "Title")) %></title>
16
                <link>http://www.yourdomain.com/news.aspx?ID=<%# DataBinder.Eval(Container.DataItem, "ArticleID") %></link>
17
                <author><%# RemoveIllegalCharacters(DataBinder.Eval(Container.DataItem, "Author"))%></author>
18
                <pubDate><%# String.Format("{0:R}", DataBinder.Eval(Container.DataItem, "DatePublished"))%></pubDate>
19
                <description><%# RemoveIllegalCharacters(DataBinder.Eval(Container.DataItem, "Description"))%></description>
20
        </item>
21
        </ItemTemplate>
22
        <FooterTemplate>
23
                </channel>
24
            </rss>  
25
        </FooterTemplate>
26
</asp:Repeater>

Das erste, was erwähnenswert ist hier, dass der rss.aspx-Datei oben enthält nur das Repeater-Steuerelement (RepeaterRSS) und keine anderen HTML-markup oder Web-Steuerelemente. Denn wir wollen, dass die Seite zu emittieren nichts, aber die XML-Ausgabe. Wir setzen den ContentType der @Page-Direktive auf "text/xml", um anzugeben, dass die Ausgabe des rss.aspx-Seite ist ein XML-Dokument.

Im HeaderTemplate Vorlage des Repeater-Steuerelement, legen wir das - und das - Elemente.

Weiter, in der ItemTemplate -, legen wir den - Elemente, die mit der , <link>, <author>, <pubDate> und <description> - Elemente, wie der Platz für die Datenbank-Felder. Wir nennen die RemoveIllegalCharacters () - Funktion, wenn Sie den Titel, Autor und Beschreibung Datenbank-Felder der XML-Ausgabe. Denken Sie daran, diese Funktion einfach ersetzt illegale XML-Zeichen mit Ihren entity-Referenzen.

Endlich, die DatePublished Datenbank-Feld, trat in den - element formatiert ist mithilfe der String.Format-Methode. Die standard Formatbezeichner, R, Formate der DatePublished Wert entsprechend nach RFC 822 -, Datum-und Uhrzeit-Angabe. Dies beginnt mit einem Tag optional dreibuchstabige Abkürzung und Komma, gefolgt von täglich erforderlich, die drei Buchstaben abgekürzt Monat und dann das Jahr, gefolgt von einer Zeit mit der Zeitzone Namen, wie Do, 4. November 2010 20:50:26 GMT.


Das Ergebnis

Und da haben wir es! Mit minimalem Aufwand haben wir erstellt einen benutzerdefinierten RSS-feed für ein ASP.NET -Anwendung.

The Resulting Feed

Der Vollständige Code

Der rss.aspx-Datei

1
<%@ Page Language="C#" ContentType="text/xml" AutoEventWireup="true" CodeBehind="rss.aspx.cs" Inherits="NettutsTutorial2.rss" %>
2
3
<asp:Repeater ID="RepeaterRSS" runat="server">
4
        <HeaderTemplate>
5
           <rss version="2.0">
6
                <channel>
7
                    <title>Name of the Website</title>
8
                    <link>http://www.yourdomain.com</link>
9
                    <description>
10
                    Short description of the website.
11
                    </description>
12
        </HeaderTemplate>
13
        <ItemTemplate>
14
            <item>
15
                <title><%# RemoveIllegalCharacters(DataBinder.Eval(Container.DataItem, "Title")) %></title>
16
                <link>http://www.yourdomain.com/news.aspx?ID=<%# DataBinder.Eval(Container.DataItem, "ArticleID") %></link>
17
                <author><%# RemoveIllegalCharacters(DataBinder.Eval(Container.DataItem, "Author"))%></author>
18
                <pubDate><%# String.Format("{0:R}", DataBinder.Eval(Container.DataItem, "DatePublished"))%></pubDate>
19
                <description><%# RemoveIllegalCharacters(DataBinder.Eval(Container.DataItem, "Description"))%></description>
20
        </item>
21
        </ItemTemplate>
22
        <FooterTemplate>
23
                </channel>
24
            </rss>  
25
        </FooterTemplate>
26
</asp:Repeater>

Der rss.aspx.cs-Datei

1
using System;
2
using System.Collections;
3
using System.Configuration;
4
using System.Data;
5
using System.Linq;
6
using System.Web;
7
using System.Web.Security;
8
using System.Web.UI;
9
using System.Web.UI.HtmlControls;
10
using System.Web.UI.WebControls;
11
using System.Web.UI.WebControls.WebParts;
12
using System.Xml.Linq;
13
using System.Data.SqlClient;
14
15
namespace NettutsTutorial2
16
{
17
    public partial class rss : System.Web.UI.Page
18
    {
19
        protected void Page_Load(object sender, EventArgs e)
20
        {
21
            // Get connection string from web.config file
22
            string connString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
23
24
            // Create SqlConnection object
25
            SqlConnection sqlConn = new SqlConnection();
26
            sqlConn.ConnectionString = connString;
27
28
            // SQL query to retrieve data from database
29
            string sqlQuery = "SELECT TOP 10 ArticleID, Title, Author, Description, DatePublished FROM News ORDER BY DatePublished DESC";
30
31
            // Create SqlCommand object
32
            SqlCommand cmd = new SqlCommand();
33
            cmd.Connection = sqlConn;
34
            cmd.CommandType = CommandType.Text;
35
            cmd.CommandText = sqlQuery;
36
37
            // open connection and then binding data into RepeaterRSS control
38
            sqlConn.Open();
39
            RepeaterRSS.DataSource = cmd.ExecuteReader();
40
            RepeaterRSS.DataBind();
41
            sqlConn.Close();
42
        }
43
44
        protected string RemoveIllegalCharacters(object input)
45
        {
46
            // cast the input to a string
47
            string data = input.ToString();
48
49
            // replace illegal characters in XML documents with their entity references
50
            data = data.Replace("&", "&amp;");
51
            data = data.Replace("\"", "&quot;");
52
            data = data.Replace("'", "&apos;");
53
            data = data.Replace("<", "&lt;");
54
            data = data.Replace(">", "&gt;");
55
56
            return data;
57
        }
58
    }
59
}

Die Web -.config-Datei

1
<?xml version="1.0"?>
2
<configuration>
3
  <configSections>
4
		<sectionGroup name="system.web.extensions" type="System.Web.Configuration.SystemWebExtensionsSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
5
			<sectionGroup name="scripting" type="System.Web.Configuration.ScriptingSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
6
				<section name="scriptResourceHandler" type="System.Web.Configuration.ScriptingScriptResourceHandlerSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>
7
				<sectionGroup name="webServices" type="System.Web.Configuration.ScriptingWebServicesSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
8
					<section name="jsonSerialization" type="System.Web.Configuration.ScriptingJsonSerializationSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="Everywhere"/>
9
					<section name="profileService" type="System.Web.Configuration.ScriptingProfileServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>
10
					<section name="authenticationService" type="System.Web.Configuration.ScriptingAuthenticationServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>
11
					<section name="roleService" type="System.Web.Configuration.ScriptingRoleServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="MachineToApplication"/>
12
				</sectionGroup>
13
			</sectionGroup>
14
		</sectionGroup>
15
	</configSections>
16
	<appSettings/>
17
	<connectionStrings>
18
		<add name="ConnectionString" connectionString="Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\Nettuts.mdf;Integrated Security=True;User Instance=True" providerName="System.Data.SqlClient"/>
19
	</connectionStrings>
20
	<system.web>
21
		<!-- 

22
            Set compilation debug="true" to insert debugging 

23
            symbols into the compiled page. Because this 

24
            affects performance, set this value to true only 

25
            during development.

26
        -->
27
		<compilation debug="true">
28
			<assemblies>
29
				<add assembly="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
30
				<add assembly="System.Data.DataSetExtensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
31
				<add assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
32
				<add assembly="System.Xml.Linq, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
33
			</assemblies>
34
		</compilation>
35
		<!--

36
            The <authentication> section enables configuration 

37
            of the security authentication mode used by 

38
            ASP.NET to identify an incoming user. 

39
        -->
40
		<authentication mode="Windows"/>
41
		<!--

42
            The <customErrors> section enables configuration 

43
            of what to do if/when an unhandled error occurs 

44
            during the execution of a request. Specifically, 

45
            it enables developers to configure html error pages 

46
            to be displayed in place of a error stack trace.

47


48
        <customErrors mode="RemoteOnly" defaultRedirect="GenericErrorPage.htm">

49
            <error statusCode="403" redirect="NoAccess.htm" />

50
            <error statusCode="404" redirect="FileNotFound.htm" />

51
        </customErrors>

52
        -->
53
		<pages>
54
			<controls>
55
				<add tagPrefix="asp" namespace="System.Web.UI" assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
56
				<add tagPrefix="asp" namespace="System.Web.UI.WebControls" assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
57
			</controls>
58
		</pages>
59
		<httpHandlers>
60
			<remove verb="*" path="*.asmx"/>
61
			<add verb="*" path="*.asmx" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
62
			<add verb="*" path="*_AppService.axd" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
63
			<add verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" validate="false"/>
64
		</httpHandlers>
65
		<httpModules>
66
			<add name="ScriptModule" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
67
		</httpModules>
68
	</system.web>
69
	<system.codedom>
70
		<compilers>
71
			<compiler language="c#;cs;csharp" extension=".cs" warningLevel="4" type="Microsoft.CSharp.CSharpCodeProvider, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
72
				<providerOption name="CompilerVersion" value="v3.5"/>
73
				<providerOption name="WarnAsError" value="false"/>
74
			</compiler>
75
		</compilers>
76
	</system.codedom>
77
	<!-- 

78
        The system.webServer section is required for running ASP.NET AJAX under Internet

79
        Information Services 7.0.  It is not necessary for previous version of IIS.

80
    -->
81
	<system.webServer>
82
		<validation validateIntegratedModeConfiguration="false"/>
83
		<modules>
84
			<remove name="ScriptModule"/>
85
			<add name="ScriptModule" preCondition="managedHandler" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
86
		</modules>
87
		<handlers>
88
			<remove name="WebServiceHandlerFactory-Integrated"/>
89
			<remove name="ScriptHandlerFactory"/>
90
			<remove name="ScriptHandlerFactoryAppServices"/>
91
			<remove name="ScriptResource"/>
92
			<add name="ScriptHandlerFactory" verb="*" path="*.asmx" preCondition="integratedMode" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
93
			<add name="ScriptHandlerFactoryAppServices" verb="*" path="*_AppService.axd" preCondition="integratedMode" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
94
			<add name="ScriptResource" preCondition="integratedMode" verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
95
		</handlers>
96
	</system.webServer>
97
	<runtime>
98
		<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
99
			<dependentAssembly>
100
				<assemblyIdentity name="System.Web.Extensions" publicKeyToken="31bf3856ad364e35"/>
101
				<bindingRedirect oldVersion="1.0.0.0-1.1.0.0" newVersion="3.5.0.0"/>
102
			</dependentAssembly>
103
			<dependentAssembly>
104
				<assemblyIdentity name="System.Web.Extensions.Design" publicKeyToken="31bf3856ad364e35"/>
105
				<bindingRedirect oldVersion="1.0.0.0-1.1.0.0" newVersion="3.5.0.0"/>
106
			</dependentAssembly>
107
		</assemblyBinding>
108
	</runtime>
109
</configuration>

Fazit

Erstellen eines RSS-Feeds mit ASP.NET ist ganz einfach, nicht wahr? Wir müssen nur verstehen, das der RSS 2.0-Spezifikation. Darüber hinaus wird mit Hilfe der .NET-Repeater-Steuerelement, können wir die render-Objekte aus einer Datenbank in das RSS-Dokument. Die meisten content-management-Systeme haben diese Funktion standardmäßig. Allerdings, wenn Sie ein Entwickler sind, und Sie bauen eine ASP.NET website von Grund auf, Sie haben jetzt die Fähigkeiten, um bauen Sie Ihre eigenen feed.

Happy Coding!