Web Scraping eines Blogs in C# mit IronWebScraper
Lassen Sie uns Iron WebScraper verwenden, um Blog-Inhalte mit C# oder VB.NET zu extrahieren. Web Scraping mit .NET ermöglicht die automatisierte Datenerfassung aus beliebigen Online-Quellen.
Diese Anleitung zeigt, wie ein WordPress-Blog (oder ein ähnlicher) mit einem Webcrawler in .NET in Inhalte zurückgescrappt werden kann.
// Define a class that extends WebScraper from IronWebScraper
public class BlogScraper : WebScraper
{
/// <summary>
/// Override this method to initialize your web-scraper.
/// Set at least one start URL and configure domain or URL patterns.
/// </summary>
public override void Init()
{
// Set your license key for IronWebScraper
License.LicenseKey = "YourLicenseKey";
// Enable logging for all actions
this.LoggingLevel = WebScraper.LogLevel.All;
// Set a directory to store output and cache files
this.WorkingDirectory = AppSetting.GetAppRoot() + @"\BlogSample\Output\";
// Enable caching with a specific duration
EnableWebCache(new TimeSpan(1, 30, 30));
// Request the start URL and specify the response handler
this.Request("http://blogSite.com/", Parse);
}
}
// Define a class that extends WebScraper from IronWebScraper
public class BlogScraper : WebScraper
{
/// <summary>
/// Override this method to initialize your web-scraper.
/// Set at least one start URL and configure domain or URL patterns.
/// </summary>
public override void Init()
{
// Set your license key for IronWebScraper
License.LicenseKey = "YourLicenseKey";
// Enable logging for all actions
this.LoggingLevel = WebScraper.LogLevel.All;
// Set a directory to store output and cache files
this.WorkingDirectory = AppSetting.GetAppRoot() + @"\BlogSample\Output\";
// Enable caching with a specific duration
EnableWebCache(new TimeSpan(1, 30, 30));
// Request the start URL and specify the response handler
this.Request("http://blogSite.com/", Parse);
}
}
' Define a class that extends WebScraper from IronWebScraper
Public Class BlogScraper
Inherits WebScraper
''' <summary>
''' Override this method to initialize your web-scraper.
''' Set at least one start URL and configure domain or URL patterns.
''' </summary>
Public Overrides Sub Init()
' Set your license key for IronWebScraper
License.LicenseKey = "YourLicenseKey"
' Enable logging for all actions
Me.LoggingLevel = WebScraper.LogLevel.All
' Set a directory to store output and cache files
Me.WorkingDirectory = AppSetting.GetAppRoot() & "\BlogSample\Output\"
' Enable caching with a specific duration
EnableWebCache(New TimeSpan(1, 30, 30))
' Request the start URL and specify the response handler
Me.Request("http://blogSite.com/", Parse)
End Sub
End Class
Wie üblich erstellen wir einen Scraper und erben von der Klasse WebScraper. In diesem Fall ist es "BlogScraper".
Wir legen ein Arbeitsverzeichnis auf "\BlogSample\Output\" fest, in dem alle unsere Ausgaben- und Cache-Dateien gespeichert werden können.
Dann aktivieren wir den Webcache, um angeforderte Seiten im Cache-Ordner "WebCache" zu speichern.
Nun lass uns eine Parse-Funktion schreiben:
/// <summary>
/// Override this method to handle the Http Response for your web scraper.
/// Add additional methods if you handle multiple page types.
/// </summary>
/// <param name="response">The HTTP Response object to parse.</param>
public override void Parse(Response response)
{
// Iterate over each link found in the section navigation
foreach (var link in response.Css("div.section-nav > ul > li > a"))
{
switch(link.TextContentClean)
{
case "Reviews":
{
// Handle reviews case
}
break;
case "Science":
{
// Handle science case
}
break;
default:
{
// Save the link title to a file
Scrape(new ScrapedData() { { "Title", link.TextContentClean } }, "BlogScraper.Jsonl");
}
break;
}
}
}
/// <summary>
/// Override this method to handle the Http Response for your web scraper.
/// Add additional methods if you handle multiple page types.
/// </summary>
/// <param name="response">The HTTP Response object to parse.</param>
public override void Parse(Response response)
{
// Iterate over each link found in the section navigation
foreach (var link in response.Css("div.section-nav > ul > li > a"))
{
switch(link.TextContentClean)
{
case "Reviews":
{
// Handle reviews case
}
break;
case "Science":
{
// Handle science case
}
break;
default:
{
// Save the link title to a file
Scrape(new ScrapedData() { { "Title", link.TextContentClean } }, "BlogScraper.Jsonl");
}
break;
}
}
}
''' <summary>
''' Override this method to handle the Http Response for your web scraper.
''' Add additional methods if you handle multiple page types.
''' </summary>
''' <param name="response">The HTTP Response object to parse.</param>
Public Overrides Sub Parse(ByVal response As Response)
' Iterate over each link found in the section navigation
For Each link In response.Css("div.section-nav > ul > li > a")
Select Case link.TextContentClean
Case "Reviews"
' Handle reviews case
Case "Science"
' Handle science case
Case Else
' Save the link title to a file
Scrape(New ScrapedData() From {
{ "Title", link.TextContentClean }
},
"BlogScraper.Jsonl")
End Select
Next link
End Sub
Innerhalb der Parse-Methode erhalten wir alle Links zu Kategorieseiten (Filme, Wissenschaft, Rezensionen usw.) aus dem oberen Menü.
Dann wechseln wir basierend auf der Link-Kategorie zu einer geeigneten Parse-Methode.
Bereiten wir unser Objektmodell für die Wissenschaftsseite vor:
/// <summary>
/// Represents a model for Science Page
/// </summary>
public class ScienceModel
{
/// <summary>
/// Gets or sets the title.
/// </summary>
public string Title { get; set; }
/// <summary>
/// Gets or sets the author.
/// </summary>
public string Author { get; set; }
/// <summary>
/// Gets or sets the date.
/// </summary>
public string Date { get; set; }
/// <summary>
/// Gets or sets the image.
/// </summary>
public string Image { get; set; }
/// <summary>
/// Gets or sets the text.
/// </summary>
public string Text { get; set; }
}
/// <summary>
/// Represents a model for Science Page
/// </summary>
public class ScienceModel
{
/// <summary>
/// Gets or sets the title.
/// </summary>
public string Title { get; set; }
/// <summary>
/// Gets or sets the author.
/// </summary>
public string Author { get; set; }
/// <summary>
/// Gets or sets the date.
/// </summary>
public string Date { get; set; }
/// <summary>
/// Gets or sets the image.
/// </summary>
public string Image { get; set; }
/// <summary>
/// Gets or sets the text.
/// </summary>
public string Text { get; set; }
}
''' <summary>
''' Represents a model for Science Page
''' </summary>
Public Class ScienceModel
''' <summary>
''' Gets or sets the title.
''' </summary>
Public Property Title() As String
''' <summary>
''' Gets or sets the author.
''' </summary>
Public Property Author() As String
''' <summary>
''' Gets or sets the date.
''' </summary>
Public Property [Date]() As String
''' <summary>
''' Gets or sets the image.
''' </summary>
Public Property Image() As String
''' <summary>
''' Gets or sets the text.
''' </summary>
Public Property Text() As String
End Class
Jetzt lass uns eine Einzelseitenscrape implementieren:
/// <summary>
/// Parses the reviews from the response.
/// </summary>
/// <param name="response">The HTTP Response object.</param>
public void ParseReviews(Response response)
{
// A list to hold Science models
var scienceList = new List<ScienceModel>();
foreach (var postBox in response.Css("section.main > div > div.post-list"))
{
var item = new ScienceModel
{
Title = postBox.Css("h1.headline > a")[0].TextContentClean,
Author = postBox.Css("div.author > a")[0].TextContentClean,
Date = postBox.Css("div.time > a")[0].TextContentClean,
Image = postBox.Css("div.image-wrapper.default-state > img")[0].Attributes["src"],
Text = postBox.Css("div.summary > p")[0].TextContentClean
};
scienceList.Add(item);
}
// Save the science list to a JSONL file
Scrape(scienceList, "BlogScience.Jsonl");
}
/// <summary>
/// Parses the reviews from the response.
/// </summary>
/// <param name="response">The HTTP Response object.</param>
public void ParseReviews(Response response)
{
// A list to hold Science models
var scienceList = new List<ScienceModel>();
foreach (var postBox in response.Css("section.main > div > div.post-list"))
{
var item = new ScienceModel
{
Title = postBox.Css("h1.headline > a")[0].TextContentClean,
Author = postBox.Css("div.author > a")[0].TextContentClean,
Date = postBox.Css("div.time > a")[0].TextContentClean,
Image = postBox.Css("div.image-wrapper.default-state > img")[0].Attributes["src"],
Text = postBox.Css("div.summary > p")[0].TextContentClean
};
scienceList.Add(item);
}
// Save the science list to a JSONL file
Scrape(scienceList, "BlogScience.Jsonl");
}
''' <summary>
''' Parses the reviews from the response.
''' </summary>
''' <param name="response">The HTTP Response object.</param>
Public Sub ParseReviews(ByVal response As Response)
' A list to hold Science models
Dim scienceList = New List(Of ScienceModel)()
For Each postBox In response.Css("section.main > div > div.post-list")
Dim item = New ScienceModel With {
.Title = postBox.Css("h1.headline > a")(0).TextContentClean,
.Author = postBox.Css("div.author > a")(0).TextContentClean,
.Date = postBox.Css("div.time > a")(0).TextContentClean,
.Image = postBox.Css("div.image-wrapper.default-state > img")(0).Attributes("src"),
.Text = postBox.Css("div.summary > p")(0).TextContentClean
}
scienceList.Add(item)
Next postBox
' Save the science list to a JSONL file
Scrape(scienceList, "BlogScience.Jsonl")
End Sub
Nachdem wir unser Modell erstellt haben, können wir das Antwortobjekt parsen, um in seine Hauptelemente (Titel, Autor, Datum, Bild, Text) einzudringen.
Dann speichern wir unsere Ergebnisse in einer separaten Datei mit Scrape(object, fileName).
Klicken Sie hier für das vollständige Tutorial über die Verwendung von IronWebScraper
Legen Sie los mit IronWebscraper
Häufig gestellte Fragen
Wie erstelle ich einen Blog-Web-Scraper in C#?
Um einen Blog-Web-Scraper in C# zu erstellen, können Sie die IronWebScraper-Bibliothek verwenden. Beginnen Sie damit, eine Klasse zu definieren, die die WebScraper-Klasse erweitert, legen Sie eine Start-URL fest, konfigurieren Sie den Scraper, um verschiedene Seitentypen zu behandeln, und verwenden Sie die Parse-Methode, um die gewünschten Informationen aus HTTP-Antworten zu extrahieren.
Was ist die Funktion der Parse-Methode beim Web-Scraping?
Beim Web-Scraping mit IronWebScraper ist die Parse-Methode entscheidend für die Verarbeitung von HTTP-Antworten. Sie hilft, Daten zu extrahieren, indem sie den Inhalt der Seiten parst, Links identifiziert und Seitentypen wie Blogposts oder andere Abschnitte kategorisiert.
Wie kann ich Web-Scraping-Daten effizient verwalten?
IronWebScraper ermöglicht eine effiziente Datenverwaltung, indem Caching konfiguriert wird, um angeforderte Seiten zu speichern und ein Arbeitsverzeichnis für Ausgabedateien einzurichten. Diese Organisation hilft, gesammelte Daten nachzuverfolgen und unnötiges erneutes Abrufen von Seiten zu reduzieren.
Wie hilft IronWebScraper beim Scraping von WordPress-Blogs?
IronWebScraper vereinfacht das Scraping von WordPress-Blogs, indem es Tools zum Navigieren in Blogstrukturen, zum Extrahieren von Post-Details und zur Handhabung verschiedener Seitentypen bereitstellt. Sie können die Bibliothek verwenden, um Posts nach Informationen wie Titel, Autor, Datum, Bild und Text zu parsen.
Kann ich IronWebScraper sowohl für C# als auch VB.NET verwenden?
Ja, IronWebScraper ist mit sowohl C# als auch VB.NET kompatibel, was es zu einer vielseitigen Wahl für Entwickler macht, die eine dieser .NET-Sprachen bevorzugen.
Wie gehe ich mit verschiedenen Seitentypen innerhalb eines Blogs um?
Sie können mit verschiedenen Seitentypen innerhalb eines Blogs umgehen, indem Sie die Parse-Methode in IronWebScraper überschreiben. Dieser Ansatz ermöglicht es Ihnen, Seiten in verschiedene Abschnitte wie Reviews und Wissenschaft zu kategorisieren und spezifische Parsing-Logik auf jeden anzuwenden.
Gibt es eine Möglichkeit, die gesammelten Blogdaten in einem strukturierten Format zu speichern?
Ja, mit IronWebScraper können Sie gesammelte Blogdaten in einem strukturierten Format wie JSONL speichern. Dieses Format ist nützlich, um jedes Datenstück im Zeilen-zu-Zeilen JSON-Format zu speichern, was es einfach macht, sie später zu verwalten und zu verarbeiten.
Wie kann ich ein Arbeitsverzeichnis für meinen Web-Scraper einrichten?
In IronWebScraper können Sie ein Arbeitsverzeichnis einrichten, indem Sie den Scraper konfigurieren, um den Speicherort festzulegen, an dem die Ausgabe- und Cache-Dateien gespeichert werden sollen. Dies hilft, die gesammelten Daten effizient zu organisieren.
Was sind einige häufige Fehlerszenarien beim Web-Scraping?
Häufige Fehlerszenarien beim Web-Scraping umfassen die Handhabung von Änderungen in der Website-Struktur, das Management von Ratenbegrenzungen und den Umgang mit Anti-Scraping-Maßnahmen. Mit IronWebScraper können Sie Fehlerbehandlung und Protokollierung implementieren, um diese Probleme zu diagnostizieren und zu lösen.
Wo finde ich Ressourcen, um mehr über die Nutzung von IronWebScraper zu erfahren?
Sie können Ressourcen und Tutorials zur Nutzung von IronWebScraper auf der Iron Software-Website finden, die detaillierte Anleitungen und Beispiele im Abschnitt der Web-Scraping-Tutorials bietet.


