1. IronWebscraper
  2. Samouczki
  3. Web scraping w języku C#

How to Scrape Data from Websites in C

Curtis Chau
Curtis Chau
Zaktualizowano:
This article was translated from English: Does it need improvement?
Translated
View the article in English

IronWebscraper to biblioteka .NET do scrapingu stron internetowych, pozyskiwania danych z sieci oraz analizowania treści internetowych. Jest to łatwa w użyciu biblioteka, którą można dodać do projektów Microsoft Visual Studio w celu wykorzystania podczas tworzenia oprogramowania i w środowisku produkcyjnym.

IronWebscraper posiada wiele unikalnych funkcji i możliwości, takich jak kontrolowanie dozwolonych i zabronionych stron, obiektów, multimediów itp. Umożliwia również zarządzanie wieloma tożsamościami, pamięcią podręczną sieci oraz wieloma innymi funkcjami, które omówimy w tym samouczku.

Rozpocznij pracę z IronWebscraper

Rozpocznij używanie IronWebScraper w swoim projekcie już dziś dzięki darmowej wersji próbnej.

Pierwszy krok:
green arrow pointer

Grupa docelowa

Ten samouczek jest skierowany do programistów posiadających podstawowe lub zaawansowane umiejętności programistyczne, którzy chcą tworzyć i wdrażać rozwiązania zapewniające zaawansowane możliwości scrapingu (scraping stron internetowych, gromadzenie i pozyskiwanie danych ze stron internetowych, analizowanie treści stron internetowych, zbieranie danych z sieci).

Obraz dotyczący scrapingu stron internetowych

Wymagane umiejętności

  1. Podstawowe zasady programowania oraz umiejętność korzystania z jednego z języków programowania Microsoftu, takich jak C# lub VB.NET
  2. Podstawowa znajomość technologii internetowych (HTML, JavaScript, jQuery, CSS itp.) oraz ich działania
  3. Podstawowa znajomość DOM, XPath, HTML i selektorów CSS

Narzędzia

  1. Microsoft Visual Studio 2010 lub nowszy
  2. Rozszerzenia dla przeglądarek przeznaczone dla programistów stron internetowych, takie jak Web Inspector dla Chrome lub Firebug dla Firefox

Dlaczego warto korzystać ze scrapingu? (Reasons and Concepts)

Jeśli chcesz stworzyć produkt lub rozwiązanie, które ma następujące możliwości:

  1. Pobieranie danych ze stron internetowych
  2. Porównaj treści, ceny, funkcje itp. z wielu stron internetowych
  3. Skanowanie i buforowanie treści stron internetowych

Jeśli przynajmniej jeden z powyższych powodów dotyczy Ciebie, to biblioteka IronWebscraper jest świetną biblioteką, która spełni Twoje potrzeby

Jak zainstalować IronWebScraper?

Po Create a New Project (patrz załącznik A) możesz dodać bibliotekę IronWebScraper do swojego projektu, automatycznie wstawiając ją za pomocą NuGet lub ręcznie instalując plik DLL.

Zainstaluj za pomocą NuGet

Aby dodać bibliotekę IronWebScraper do naszego projektu za pomocą NuGet, możemy to zrobić za pomocą interfejsu graficznego (NuGet Package Manager) lub za pomocą poleceń w konsoli Package Manager Console.

Korzystanie z menedżera pakietów NuGet

  1. Użyj myszy -> kliknij prawym przyciskiem na nazwę projektu -> Wybierz opcję zarządzania pakietem NuGet
  2. Z zakładki przeglądania -> wyszukaj IronWebScraper -> Zainstaluj
  3. Kliknij OK
  4. I gotowe

Korzystanie z konsoli pakietów NuGet

  1. Z menu Narzędzia -> Menedżer pakietów NuGet -> Konsola menedżera pakietów
  2. Wybierz projekt biblioteki klas jako projekt domyślny
  3. Uruchom polecenie -> Install-Package IronWebScraper

Zainstaluj ręcznie

  1. Przejdź do </https:>
  2. Kliknij IronWebScraper lub przejdź bezpośrednio na stronę, korzystając z adresu URL https://ironsoftware.com/csharp/webscraper/
  3. Kliknij Pobierz DLL.
  4. Rozpakuj pobrany plik

  5. W programie Visual Studio kliknij prawym przyciskiem myszy na projekt -> dodaj -> odwołanie -> przeglądaj

    Dodaj IronWebScraper przy użyciu biblioteki DLL

  6. Przejdź do wyodrębnionego folderu -> netstandard2.0 -> i zaznacz wszystkie pliki .dll

    Dodaj IronWebScraper przy użyciu biblioteki DLL 2

  7. I gotowe!

HelloScraper – nasz pierwszy przykład IronWebscraper

Jak zwykle zaczniemy od wdrożenia aplikacji Hello Scraper, aby zrobić pierwszy krok z wykorzystaniem IronWebScraper.

  • Stworzyliśmy nową aplikację konsolową o nazwie "IronWebScraperSample"

Kroki tworzenia przykładowego kodu dla IronWebscraper

  1. Utwórz folder i nazwij go "HelloScraperSample"

  2. Następnie dodaj nową klasę i nazwij ją HelloScraper HelloScraper Dodaj klasę

  3. Dodaj ten fragment kodu do HelloScraper

    public class HelloScraper : WebScraper
{
    /// <summary>
    /// Override this method to initialize your web scraper.
    /// Important tasks will be to request at least one start URL and set allowed/banned domain or URL patterns.
    /// </summary>
    public override void Init()
    {
        License.LicenseKey = "LicenseKey"; // Write License Key
        this.LoggingLevel = WebScraper.LogLevel.All; // Log all events
        this.Request("https://blog.scrapinghub.com", Parse); // Initialize a web request to the given URL
    }

    /// <summary>
    /// Override this method to create the default Response handler for your web scraper.
    /// If you have multiple page types, you can add additional similar methods.
    /// </summary>
    /// <param name="response">The HTTP Response object to parse</param>
    public override void Parse(Response response)
    {
        // Set working directory for the project
        this.WorkingDirectory = AppSetting.GetAppRoot() + @"\HelloScraperSample\Output\";
        // Loop on all links
        foreach (var titleLink in response.Css("h2.entry-title a"))
        {
            // Read link text
            string title = titleLink.TextContentClean;
            // Save result to file
            Scrape(new ScrapedData() { { "Title", title } }, "HelloScraper.json");
        }

        // Loop on all links for pagination
        if (response.CssExists("div.prev-post > a[href]"))
        {
            // Get next page URL
            var nextPage = response.Css("div.prev-post > a[href]")[0].Attributes["href"];
            // Scrape next URL
            this.Request(nextPage, Parse);
        }
    }
}
    public class HelloScraper : WebScraper
{
    /// <summary>
    /// Override this method to initialize your web scraper.
    /// Important tasks will be to request at least one start URL and set allowed/banned domain or URL patterns.
    /// </summary>
    public override void Init()
    {
        License.LicenseKey = "LicenseKey"; // Write License Key
        this.LoggingLevel = WebScraper.LogLevel.All; // Log all events
        this.Request("https://blog.scrapinghub.com", Parse); // Initialize a web request to the given URL
    }

    /// <summary>
    /// Override this method to create the default Response handler for your web scraper.
    /// If you have multiple page types, you can add additional similar methods.
    /// </summary>
    /// <param name="response">The HTTP Response object to parse</param>
    public override void Parse(Response response)
    {
        // Set working directory for the project
        this.WorkingDirectory = AppSetting.GetAppRoot() + @"\HelloScraperSample\Output\";
        // Loop on all links
        foreach (var titleLink in response.Css("h2.entry-title a"))
        {
            // Read link text
            string title = titleLink.TextContentClean;
            // Save result to file
            Scrape(new ScrapedData() { { "Title", title } }, "HelloScraper.json");
        }

        // Loop on all links for pagination
        if (response.CssExists("div.prev-post > a[href]"))
        {
            // Get next page URL
            var nextPage = response.Css("div.prev-post > a[href]")[0].Attributes["href"];
            // Scrape next URL
            this.Request(nextPage, Parse);
        }
    }
}
    Public Class HelloScraper
	Inherits WebScraper

	''' <summary>
	''' Override this method to initialize your web scraper.
	''' Important tasks will be to request at least one start URL and set allowed/banned domain or URL patterns.
	''' </summary>
	Public Overrides Sub Init()
		License.LicenseKey = "LicenseKey" ' Write License Key
		Me.LoggingLevel = WebScraper.LogLevel.All ' Log all events
		Me.Request("https://blog.scrapinghub.com", AddressOf Parse) ' Initialize a web request to the given URL
	End Sub

	''' <summary>
	''' Override this method to create the default Response handler for your web scraper.
	''' If you have multiple page types, you can add additional similar methods.
	''' </summary>
	''' <param name="response">The HTTP Response object to parse</param>
	Public Overrides Sub Parse(ByVal response As Response)
		' Set working directory for the project
		Me.WorkingDirectory = AppSetting.GetAppRoot() & "\HelloScraperSample\Output\"
		' Loop on all links
		For Each titleLink In response.Css("h2.entry-title a")
			' Read link text
			Dim title As String = titleLink.TextContentClean
			' Save result to file
			Scrape(New ScrapedData() From {
				{ "Title", title }
			},
			"HelloScraper.json")
		Next titleLink

		' Loop on all links for pagination
		If response.CssExists("div.prev-post > a[href]") Then
			' Get next page URL
			Dim nextPage = response.Css("div.prev-post > a[href]")(0).Attributes("href")
			' Scrape next URL
			Me.Request(nextPage, AddressOf Parse)
		End If
	End Sub
End Class
    $vbLabelText   $csharpLabel

  4. Aby uruchomić Scrape, dodaj ten fragment kodu do Main

    static void Main(string[] args)
{
    // Create Object From Hello Scrape class
    HelloScraperSample.HelloScraper scrape = new HelloScraperSample.HelloScraper();
    // Start Scraping
    scrape.Start();
}
    static void Main(string[] args)
{
    // Create Object From Hello Scrape class
    HelloScraperSample.HelloScraper scrape = new HelloScraperSample.HelloScraper();
    // Start Scraping
    scrape.Start();
}
    Shared Sub Main(ByVal args() As String)
	' Create Object From Hello Scrape class
	Dim scrape As New HelloScraperSample.HelloScraper()
	' Start Scraping
	scrape.Start()
End Sub
    $vbLabelText   $csharpLabel
  5. Wynik zostanie zapisany w pliku o formacie WebScraper.WorkingDirectory/classname.Json Wynik HelloScraper

Przegląd kodu

Scrape.Start() uruchamia logikę scrapingu w następujący sposób:

  1. Wywołuje metodę Init() w celu zainicjowania zmiennych, zebrania właściwości i atrybutów zachowania.
  2. Ustawia żądanie strony startowej w Init() za pomocą Request("https://blog.scrapinghub.com", Parse).
  3. Obsługuje wiele żądań HTTP i wątków równolegle, zapewniając synchronizację kodu i ułatwiając debugowanie.
  4. Metoda Parse() jest uruchamiana po Init() w celu przetworzenia odpowiedzi, wyodrębnienia danych przy użyciu selektorów CSS i zapisania ich w formacie JSON.

Funkcje i opcje biblioteki IronWebscraper

Zaktualizowaną dokumentację można znaleźć w pliku ZIP pobranym przy użyciu metody instalacji ręcznej (IronWebScraper Documentation.chm File) lub sprawdzić w dokumentacji online, aby uzyskać najnowszą aktualizację biblioteki pod adresem https://ironsoftware.com/csharp/webscraper/object-reference/.

Aby rozpocząć korzystanie z IronWebScraper w swoim projekcie, należy dziedziczyć po klasie IronWebScraper.WebScraper, która rozszerza bibliotekę klas i dodaje do niej funkcję scrapingu. Ponadto należy zaimplementować metody Init() i Parse(Response response).

namespace IronWebScraperEngine
{
    public class NewsScraper : IronWebScraper.WebScraper
    {
        public override void Init()
        {
            throw new NotImplementedException();
        }

        public override void Parse(Response response)
        {
            throw new NotImplementedException();
        }
    }
}
namespace IronWebScraperEngine
{
    public class NewsScraper : IronWebScraper.WebScraper
    {
        public override void Init()
        {
            throw new NotImplementedException();
        }

        public override void Parse(Response response)
        {
            throw new NotImplementedException();
        }
    }
}
Namespace IronWebScraperEngine
	Public Class NewsScraper
		Inherits IronWebScraper.WebScraper

		Public Overrides Sub Init()
			Throw New NotImplementedException()
		End Sub

		Public Overrides Sub Parse(ByVal response As Response)
			Throw New NotImplementedException()
		End Sub
	End Class
End Namespace
$vbLabelText   $csharpLabel
Właściwości \ funkcje Typ Opis
Init () Metoda Służy do konfiguracji narzędzia do scrapingu
Parse (Response response) Metoda Służy do implementacji logiki, którą wykorzysta scraper, oraz sposobu jej przetwarzania. Możliwe jest wdrożenie wielu metod dla różnych zachowań lub struktur stron.
BannedUrls, AllowedUrls, BannedDomains Kolekcje Służy do blokowania/zezwalania na adresy URL i/lub domeny. Przykład: BannedUrls.Add("*.zip", "*.exe", "*.gz", "*.pdf"); Obsługuje symbole wieloznaczne i wyrażenia regularne.
ObeyRobotsDotTxt Boolean Służy do włączania lub wyłączania odczytu i przestrzegania dyrektyw w robots.txt.
ObeyRobotsDotTxtForHost (string Host) Metoda Służy do włączania lub wyłączania odczytu i przestrzegania dyrektyw zawartych w robots.txt dla określonej domeny.
Scrape, ScrapeUnique Metoda
ThrottleMode Wymienienie Opcje wyliczeniowe: ByIpAddress, ByDomainHostName. Umożliwia inteligentne ograniczanie liczby żądań, z uwzględnieniem adresów IP hostów lub nazw domen.
EnableWebCache, EnableWebCache (TimeSpan cacheDuration) Metoda Włącza buforowanie żądań internetowych.
MaxHttpConnectionLimit Int Ustawia całkowitą liczbę dozwolonych otwartych żądań HTTP (wątków).
RateLimitPerHost TimeSpan Ustawia minimalny uprzejmy opóźnienie (przerwę) między żądaniami wysyłanymi do danej domeny lub adresu IP.
OpenConnectionLimitPerHost Int Ustawia dozwoloną liczbę równoczesnych żądań HTTP (wątków) na nazwę hosta lub adres IP.
WorkingDirectory string Ustawia ścieżkę katalogu roboczego do przechowywania danych.

Praktyczne przykłady i ćwiczenia

Pobieranie danych ze strony internetowej z filmami

Stwórzmy przykład, w którym pobieramy dane ze strony internetowej poświęconej filmom.

Dodaj nową klasę i nazwij ją MovieScraper:

Dodaj klasę MovieScraper

Struktura HTML

Oto fragment kodu HTML strony głównej, który widzimy na stronie internetowej:

<div id="movie-featured" class="movies-list movies-list-full tab-pane in fade active">
    <div data-movie-id="20746" class="ml-item">
        <a href="https://website.com/film/king-arthur-legend-of-the-sword-20746/">
            <span class="mli-quality">CAM</span>
            <img data-original="https://img.gocdn.online/2017/05/16/poster/2116d6719c710eabe83b377463230fbe-king-arthur-legend-of-the-sword.jpg" 
                 class="lazy thumb mli-thumb" alt="King Arthur: Legend of the Sword"
                  src="https://img.gocdn.online/2017/05/16/poster/2116d6719c710eabe83b377463230fbe-king-arthur-legend-of-the-sword.jpg" 
                 style="display: inline-block;">
            <span class="mli-info"><h2>King Arthur: Legend of the Sword</h2></span>
        </a>
    </div>
    <div data-movie-id="20724" class="ml-item">
        <a href="https://website.com/film/snatched-20724/" >
            <span class="mli-quality">CAM</span>
            <img data-original="https://img.gocdn.online/2017/05/16/poster/5ef66403dc331009bdb5aa37cfe819ba-snatched.jpg" 
                 class="lazy thumb mli-thumb" alt="Snatched" 
                 src="https://img.gocdn.online/2017/05/16/poster/5ef66403dc331009bdb5aa37cfe819ba-snatched.jpg" 
                 style="display: inline-block;">
            <span class="mli-info"><h2>Snatched</h2></span>
        </a>
    </div>
</div>
<div id="movie-featured" class="movies-list movies-list-full tab-pane in fade active">
    <div data-movie-id="20746" class="ml-item">
        <a href="https://website.com/film/king-arthur-legend-of-the-sword-20746/">
            <span class="mli-quality">CAM</span>
            <img data-original="https://img.gocdn.online/2017/05/16/poster/2116d6719c710eabe83b377463230fbe-king-arthur-legend-of-the-sword.jpg" 
                 class="lazy thumb mli-thumb" alt="King Arthur: Legend of the Sword"
                  src="https://img.gocdn.online/2017/05/16/poster/2116d6719c710eabe83b377463230fbe-king-arthur-legend-of-the-sword.jpg" 
                 style="display: inline-block;">
            <span class="mli-info"><h2>King Arthur: Legend of the Sword</h2></span>
        </a>
    </div>
    <div data-movie-id="20724" class="ml-item">
        <a href="https://website.com/film/snatched-20724/" >
            <span class="mli-quality">CAM</span>
            <img data-original="https://img.gocdn.online/2017/05/16/poster/5ef66403dc331009bdb5aa37cfe819ba-snatched.jpg" 
                 class="lazy thumb mli-thumb" alt="Snatched" 
                 src="https://img.gocdn.online/2017/05/16/poster/5ef66403dc331009bdb5aa37cfe819ba-snatched.jpg" 
                 style="display: inline-block;">
            <span class="mli-info"><h2>Snatched</h2></span>
        </a>
    </div>
</div>
HTML

Jak widać, mamy identyfikator filmu, tytuł oraz link do strony szczegółowej. Zacznijmy zbierać te dane:

public class MovieScraper : WebScraper
{
    public override void Init()
    {
        License.LicenseKey = "LicenseKey";
        this.LoggingLevel = WebScraper.LogLevel.All;
        this.WorkingDirectory = AppSetting.GetAppRoot() + @"\MovieSample\Output\";
        this.Request("www.website.com", Parse);
    }

    public override void Parse(Response response)
    {
        foreach (var div in response.Css("#movie-featured > div"))
        {
            if (div.GetAttribute("class") != "clearfix")
            {
                var movieId = div.GetAttribute("data-movie-id");
                var link = div.Css("a")[0];
                var movieTitle = link.TextContentClean;
                Scrape(new ScrapedData() { { "MovieId", movieId }, { "MovieTitle", movieTitle } }, "Movie.Jsonl");
            }
        }           
    }
}
public class MovieScraper : WebScraper
{
    public override void Init()
    {
        License.LicenseKey = "LicenseKey";
        this.LoggingLevel = WebScraper.LogLevel.All;
        this.WorkingDirectory = AppSetting.GetAppRoot() + @"\MovieSample\Output\";
        this.Request("www.website.com", Parse);
    }

    public override void Parse(Response response)
    {
        foreach (var div in response.Css("#movie-featured > div"))
        {
            if (div.GetAttribute("class") != "clearfix")
            {
                var movieId = div.GetAttribute("data-movie-id");
                var link = div.Css("a")[0];
                var movieTitle = link.TextContentClean;
                Scrape(new ScrapedData() { { "MovieId", movieId }, { "MovieTitle", movieTitle } }, "Movie.Jsonl");
            }
        }           
    }
}
Public Class MovieScraper
	Inherits WebScraper

	Public Overrides Sub Init()
		License.LicenseKey = "LicenseKey"
		Me.LoggingLevel = WebScraper.LogLevel.All
		Me.WorkingDirectory = AppSetting.GetAppRoot() & "\MovieSample\Output\"
		Me.Request("www.website.com", AddressOf Parse)
	End Sub

	Public Overrides Sub Parse(ByVal response As Response)
		For Each div In response.Css("#movie-featured > div")
			If div.GetAttribute("class") <> "clearfix" Then
				Dim movieId = div.GetAttribute("data-movie-id")
				Dim link = div.Css("a")(0)
				Dim movieTitle = link.TextContentClean
				Scrape(New ScrapedData() From {
					{ "MovieId", movieId },
					{ "MovieTitle", movieTitle }
				},
				"Movie.Jsonl")
			End If
		Next div
	End Sub
End Class
$vbLabelText   $csharpLabel

Klasa strukturalna Movie

Aby przechowywać nasze sformatowane dane, zaimplementujmy klasę movie:

public class Movie
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string URL { get; set; }
}
public class Movie
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string URL { get; set; }
}
Public Class Movie
    Public Property Id As Integer
    Public Property Title As String
    Public Property URL As String
End Class
$vbLabelText   $csharpLabel

Teraz zaktualizujmy nasz kod, aby używał klasy Movie:

public class MovieScraper : WebScraper
{
    public override void Init()
    {
        License.LicenseKey = "LicenseKey";
        this.LoggingLevel = WebScraper.LogLevel.All;
        this.WorkingDirectory = AppSetting.GetAppRoot() + @"\MovieSample\Output\";
        this.Request("https://website.com/", Parse);
    }

    public override void Parse(Response response)
    {
        foreach (var div in response.Css("#movie-featured > div"))
        {
            if (div.GetAttribute("class") != "clearfix")
            {
                var movie = new Movie
                {
                    Id = Convert.ToInt32(div.GetAttribute("data-movie-id")),
                    Title = div.Css("a")[0].TextContentClean,
                    URL = div.Css("a")[0].Attributes["href"]
                };
                Scrape(movie, "Movie.Jsonl");
            }
        }
    }
}
public class MovieScraper : WebScraper
{
    public override void Init()
    {
        License.LicenseKey = "LicenseKey";
        this.LoggingLevel = WebScraper.LogLevel.All;
        this.WorkingDirectory = AppSetting.GetAppRoot() + @"\MovieSample\Output\";
        this.Request("https://website.com/", Parse);
    }

    public override void Parse(Response response)
    {
        foreach (var div in response.Css("#movie-featured > div"))
        {
            if (div.GetAttribute("class") != "clearfix")
            {
                var movie = new Movie
                {
                    Id = Convert.ToInt32(div.GetAttribute("data-movie-id")),
                    Title = div.Css("a")[0].TextContentClean,
                    URL = div.Css("a")[0].Attributes["href"]
                };
                Scrape(movie, "Movie.Jsonl");
            }
        }
    }
}
Public Class MovieScraper
	Inherits WebScraper

	Public Overrides Sub Init()
		License.LicenseKey = "LicenseKey"
		Me.LoggingLevel = WebScraper.LogLevel.All
		Me.WorkingDirectory = AppSetting.GetAppRoot() & "\MovieSample\Output\"
		Me.Request("https://website.com/", AddressOf Parse)
	End Sub

	Public Overrides Sub Parse(ByVal response As Response)
		For Each div In response.Css("#movie-featured > div")
			If div.GetAttribute("class") <> "clearfix" Then
				Dim movie As New Movie With {
					.Id = Convert.ToInt32(div.GetAttribute("data-movie-id")),
					.Title = div.Css("a")(0).TextContentClean,
					.URL = div.Css("a")(0).Attributes("href")
				}
				Scrape(movie, "Movie.Jsonl")
			End If
		Next div
	End Sub
End Class
$vbLabelText   $csharpLabel

Szczegółowe pobieranie treści ze stron

Rozszerzmy naszą klasę Movie, aby zawierała nowe właściwości dla szczegółowych informacji:

public class Movie
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string URL { get; set; }
    public string Description { get; set; }
    public List<string> Genre { get; set; }
    public List<string> Actor { get; set; }
}
public class Movie
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string URL { get; set; }
    public string Description { get; set; }
    public List<string> Genre { get; set; }
    public List<string> Actor { get; set; }
}
Public Class Movie
    Public Property Id As Integer
    Public Property Title As String
    Public Property URL As String
    Public Property Description As String
    Public Property Genre As List(Of String)
    Public Property Actor As List(Of String)
End Class
$vbLabelText   $csharpLabel

Następnie przejdź do strony szczegółowej, aby ją zeskrobać, korzystając z rozszerzonych możliwości IronWebScraper:

public class MovieScraper : WebScraper
{
    public override void Init()
    {
        License.LicenseKey = "LicenseKey";
        this.LoggingLevel = WebScraper.LogLevel.All;
        this.WorkingDirectory = AppSetting.GetAppRoot() + @"\MovieSample\Output\";
        this.Request("https://domain/", Parse);
    }

    public override void Parse(Response response)
    {
        foreach (var div in response.Css("#movie-featured > div"))
        {
            if (div.GetAttribute("class") != "clearfix")
            {
                var movie = new Movie
                {
                    Id = Convert.ToInt32(div.GetAttribute("data-movie-id")),
                    Title = div.Css("a")[0].TextContentClean,
                    URL = div.Css("a")[0].Attributes["href"]
                };
                this.Request(movie.URL, ParseDetails, new MetaData() { { "movie", movie } });
            }
        }           
    }

    public void ParseDetails(Response response)
    {
        var movie = response.MetaData.Get<Movie>("movie");
        var div = response.Css("div.mvic-desc")[0];
        movie.Description = div.Css("div.desc")[0].TextContentClean;
        movie.Genre = div.Css("div > p > a").Select(element => element.TextContentClean).ToList();
        movie.Actor = div.Css("div > p:nth-child(2) > a").Select(element => element.TextContentClean).ToList();

        Scrape(movie, "Movie.Jsonl");
    }
}
public class MovieScraper : WebScraper
{
    public override void Init()
    {
        License.LicenseKey = "LicenseKey";
        this.LoggingLevel = WebScraper.LogLevel.All;
        this.WorkingDirectory = AppSetting.GetAppRoot() + @"\MovieSample\Output\";
        this.Request("https://domain/", Parse);
    }

    public override void Parse(Response response)
    {
        foreach (var div in response.Css("#movie-featured > div"))
        {
            if (div.GetAttribute("class") != "clearfix")
            {
                var movie = new Movie
                {
                    Id = Convert.ToInt32(div.GetAttribute("data-movie-id")),
                    Title = div.Css("a")[0].TextContentClean,
                    URL = div.Css("a")[0].Attributes["href"]
                };
                this.Request(movie.URL, ParseDetails, new MetaData() { { "movie", movie } });
            }
        }           
    }

    public void ParseDetails(Response response)
    {
        var movie = response.MetaData.Get<Movie>("movie");
        var div = response.Css("div.mvic-desc")[0];
        movie.Description = div.Css("div.desc")[0].TextContentClean;
        movie.Genre = div.Css("div > p > a").Select(element => element.TextContentClean).ToList();
        movie.Actor = div.Css("div > p:nth-child(2) > a").Select(element => element.TextContentClean).ToList();

        Scrape(movie, "Movie.Jsonl");
    }
}
Public Class MovieScraper
	Inherits WebScraper

	Public Overrides Sub Init()
		License.LicenseKey = "LicenseKey"
		Me.LoggingLevel = WebScraper.LogLevel.All
		Me.WorkingDirectory = AppSetting.GetAppRoot() & "\MovieSample\Output\"
		Me.Request("https://domain/", AddressOf Parse)
	End Sub

	Public Overrides Sub Parse(ByVal response As Response)
		For Each div In response.Css("#movie-featured > div")
			If div.GetAttribute("class") <> "clearfix" Then
				Dim movie As New Movie With {
					.Id = Convert.ToInt32(div.GetAttribute("data-movie-id")),
					.Title = div.Css("a")(0).TextContentClean,
					.URL = div.Css("a")(0).Attributes("href")
				}
				Me.Request(movie.URL, AddressOf ParseDetails, New MetaData() From {
					{ "movie", movie }
				})
			End If
		Next div
	End Sub

	Public Sub ParseDetails(ByVal response As Response)
		Dim movie = response.MetaData.Get(Of Movie)("movie")
		Dim div = response.Css("div.mvic-desc")(0)
		movie.Description = div.Css("div.desc")(0).TextContentClean
		movie.Genre = div.Css("div > p > a").Select(Function(element) element.TextContentClean).ToList()
		movie.Actor = div.Css("div > p:nth-child(2) > a").Select(Function(element) element.TextContentClean).ToList()

		Scrape(movie, "Movie.Jsonl")
	End Sub
End Class
$vbLabelText   $csharpLabel

Funkcje biblioteki IronWebscraper

Funkcja HttpIdentity

Niektóre systemy wymagają, aby użytkownik był zalogowany, aby móc przeglądać treści; użyj HttpIdentity dla danych uwierzytelniających:

HttpIdentity id = new HttpIdentity
{
    NetworkUsername = "username",
    NetworkPassword = "pwd"
};
Identities.Add(id);
HttpIdentity id = new HttpIdentity
{
    NetworkUsername = "username",
    NetworkPassword = "pwd"
};
Identities.Add(id);
Dim id As New HttpIdentity With {
	.NetworkUsername = "username",
	.NetworkPassword = "pwd"
}
Identities.Add(id)
$vbLabelText   $csharpLabel

Włącz pamięć podręczną sieci

Buforuj żądane strony w celu ponownego wykorzystania podczas tworzenia oprogramowania:

public override void Init()
{
    License.LicenseKey = "LicenseKey";
    this.LoggingLevel = WebScraper.LogLevel.All;
    this.WorkingDirectory = AppSetting.GetAppRoot() + @"\ShoppingSiteSample\Output\";
    EnableWebCache();
    this.Request("http://www.WebSite.com", Parse);
}
public override void Init()
{
    License.LicenseKey = "LicenseKey";
    this.LoggingLevel = WebScraper.LogLevel.All;
    this.WorkingDirectory = AppSetting.GetAppRoot() + @"\ShoppingSiteSample\Output\";
    EnableWebCache();
    this.Request("http://www.WebSite.com", Parse);
}
Public Overrides Sub Init()
	License.LicenseKey = "LicenseKey"
	Me.LoggingLevel = WebScraper.LogLevel.All
	Me.WorkingDirectory = AppSetting.GetAppRoot() & "\ShoppingSiteSample\Output\"
	EnableWebCache()
	Me.Request("http://www.WebSite.com", Parse)
End Sub
$vbLabelText   $csharpLabel

Ograniczanie przepustowości

Kontroluj numery połączeń i prędkość:

public override void Init()
{
    License.LicenseKey = "LicenseKey";
    this.LoggingLevel = WebScraper.LogLevel.All;
    this.WorkingDirectory = AppSetting.GetAppRoot() + @"\ShoppingSiteSample\Output\";
    this.MaxHttpConnectionLimit = 80;
    this.RateLimitPerHost = TimeSpan.FromMilliseconds(50);
    this.OpenConnectionLimitPerHost = 25;
    this.ObeyRobotsDotTxt = false;
    this.ThrottleMode = Throttle.ByDomainHostName;
    this.Request("https://www.Website.com", Parse);
}
public override void Init()
{
    License.LicenseKey = "LicenseKey";
    this.LoggingLevel = WebScraper.LogLevel.All;
    this.WorkingDirectory = AppSetting.GetAppRoot() + @"\ShoppingSiteSample\Output\";
    this.MaxHttpConnectionLimit = 80;
    this.RateLimitPerHost = TimeSpan.FromMilliseconds(50);
    this.OpenConnectionLimitPerHost = 25;
    this.ObeyRobotsDotTxt = false;
    this.ThrottleMode = Throttle.ByDomainHostName;
    this.Request("https://www.Website.com", Parse);
}
Public Overrides Sub Init()
	License.LicenseKey = "LicenseKey"
	Me.LoggingLevel = WebScraper.LogLevel.All
	Me.WorkingDirectory = AppSetting.GetAppRoot() & "\ShoppingSiteSample\Output\"
	Me.MaxHttpConnectionLimit = 80
	Me.RateLimitPerHost = TimeSpan.FromMilliseconds(50)
	Me.OpenConnectionLimitPerHost = 25
	Me.ObeyRobotsDotTxt = False
	Me.ThrottleMode = Throttle.ByDomainHostName
	Me.Request("https://www.Website.com", Parse)
End Sub
$vbLabelText   $csharpLabel

Właściwości ograniczania przepustowości

  • MaxHttpConnectionLimit
    całkowita liczba dozwolonych otwartych żądań HTTP (wątków)
  • RateLimitPerHost
    minimalna uprzejma przerwa (pauza) między żądaniem wysłanym do danej domeny lub adresu IP
  • OpenConnectionLimitPerHost
    dozwolona liczba równoczesnych żądań HTTP (wątków) na nazwę hosta lub adres IP
  • ThrottleMode
    Sprawia, że WEBSCRAPER inteligentnie ogranicza liczbę żądań nie tylko według nazwy hosta, ale także według adresów IP serwerów hosta. Jest to uprzejme rozwiązanie na wypadek, gdyby wiele domen, z których pobierane są dane, było hostowanych na tej samej maszynie.

Załącznik

Jak stworzyć aplikację Windows Form?

Użyj programu Visual Studio 2013 lub nowszego.

  1. Otwórz program Visual Studio.

  2. Plik -> Nowy -> Projekt Enterprise 2015

  3. Wybierz Visual C# lub VB -> Windows -> Aplikacja Windows Forms. Utwórz aplikację dla systemu Windows

Nazwa projektu: IronScraperSample
Lokalizacja: Wybierz lokalizację na dysku.

Jak stworzyć aplikację z formularzami internetowymi ASP.NET?

  1. Otwórz program Visual Studio. Enterprise 2015

  2. Plik -> Nowy -> Projekt Plik Nowy projekt

  3. Wybierz Visual C# lub VB -> Web -> Aplikacja internetowa ASP.NET (.NET Framework). Aplikacja internetowa ASP .NET

Nazwa projektu: IronScraperSample
Lokalizacja: Wybierz lokalizację na dysku.

  1. W szablonach ASP.NET wybierz pusty szablon i zaznacz opcję Web Forms. Szablony ASP .NET

  2. Utworzono podstawowy projekt formularza internetowego ASP.NET. Projekt formularza internetowego ASP .NET

Pobierz pełny kod przykładowego projektu samouczka tutaj.

Często Zadawane Pytania

Jak pobierać dane ze stron internetowych w języku C#?

Możesz użyć IronWebscraper do pobierania danych ze stron internetowych w języku C#. Zacznij od zainstalowania biblioteki za pośrednictwem NuGet i skonfiguruj podstawową aplikację konsolową, aby rozpocząć wydajne pozyskiwanie danych z sieci.

Jakie są warunki wstępne do scrapingu stron internetowych w języku C#?

Aby wykonywać web scraping w języku C#, należy posiadać podstawowe umiejętności programistyczne w języku C# lub VB.NET oraz rozumieć technologie internetowe, takie jak HTML, JavaScript i CSS, a także znać DOM, XPath i selektory CSS.

Jak zainstalować bibliotekę do scrapingu stron internetowych w projekcie .NET?

Aby zainstalować IronWebscraper w projekcie .NET, należy użyć konsoli menedżera pakietów NuGet, wpisując polecenie Install-Package IronWebscraper, lub przejść do interfejsu menedżera pakietów NuGet w programie Visual Studio.

Jak mogę zaimplementować ograniczanie liczby żądań w moim narzędziu do scrapingu stron internetowych?

IronWebscraper pozwala na wdrożenie ograniczania żądań w celu zarządzania częstotliwością żądań wysyłanych do serwera. Można to skonfigurować za pomocą ustawień takich jak MaxHttpConnectionLimit, RateLimitPerHost i OpenConnectionLimitPerHost.

Jaki jest cel włączenia pamięci podręcznej w procesie scrapingu stron internetowych?

Włączenie pamięci podręcznej w web scrapingu pomaga zmniejszyć liczbę żądań wysyłanych do serwera poprzez przechowywanie i ponowne wykorzystywanie poprzednich odpowiedzi. Można to skonfigurować w IronWebscraper za pomocą metody EnableWebCache.

Jak można rozwiązać kwestię uwierzytelniania podczas scrapingu stron internetowych?

Dzięki IronWebscraper możesz używać HttpIdentity do zarządzania uwierzytelnianiem, co pozwala na dostęp do treści za formularzami logowania lub w obszarach o ograniczonym dostępie, umożliwiając w ten sposób pobieranie zasobów chronionych.

Jaki jest prosty przykład narzędzia do scrapingu stron internetowych w języku C#?

„HelloScraper” to prosty przykład podany w samouczku. Pokazuje on konfigurację podstawowego narzędzia do scrapingu stron internetowych przy użyciu IronWebscraper, w tym sposób inicjowania żądań i analizowania odpowiedzi.

Jak mogę rozszerzyć mój web scraper, aby obsługiwał złożone struktury stron?

Korzystając z IronWebscraper, możesz rozszerzyć swój scraper, aby obsługiwał złożone struktury stron, dostosowując metody Parse do przetwarzania różnych typów stron, co pozwala na elastyczne strategie pozyskiwania danych.

Jakie są zalety korzystania z biblioteki do scrapingu stron internetowych?

Korzystanie z biblioteki do scrapingu stron internetowych, takiej jak IronWebscraper, oferuje korzyści, takie jak usprawnione pozyskiwanie danych, zarządzanie domenami, ograniczanie liczby żądań, buforowanie oraz obsługa uwierzytelniania, co umożliwia wydajną obsługę zadań związanych ze scrapingiem stron internetowych.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej
Gotowy, aby rozpocząć?
Nuget Pliki do pobrania 137,906 | Wersja: 2026.6 just released
Still Scrolling Icon

Wciąż przewijasz?

Czy chcesz szybko dowodu? PM > Install-Package IronWebScraper
uruchom przykład obserwuj, jak twoja docelowa strona przekształca się w dane strukturalne.