Headless Browser in C#: Setup und Codebeispiele

Mit Headless-Browsern können Sie Webaufgaben ohne grafische Benutzeroberfläche automatisieren. In C# werden sie häufig zum Testen, Web Scraping und Content Management verwendet. Zwei beliebte Tools sind PuppenspielerSharp (optimiert für Chrome/Chromium) und Selenium WebDriver (unterstützt mehrere Browser). Hier ein Vergleich:

Merkmal	PuppenspielerSharp	Selenium WebDriver
Browser-Unterstützung	Chrom / Chrom	Chrome, Firefox, Edge usw.
Komplexität des Setups	Einfach (automatischer Chromium-Download)	Erfordert separate Treiberinstallation
Leistung	Schneller für Chrome/Chromium	Browserübergreifend konsistent
API-Design	Modernes, versprechensbasiertes	Traditionell, objektorientiert
Memory Usage	Senken	Variiert je nach Browser

Hauptvorteile von Headless-Browsern:

• Geschwindigkeit: Schnelleres Testen ohne GUI-Rendering.
• Effizienz: Verbraucht weniger Speicher und CPU.
• Automation: Bewältigt Aufgaben wie Datenscraping, Tests und Formularübermittlungen.

Zur schnellen Einrichtung:

1. Installieren Sie das .NET-SDK und erforderliche Pakete (PuppeteerSharp or Selenium.WebDriver).
2. Verwenden Sie PuppeteerSharp für Chrome-spezifische Automatisierung oder Selenium für browserübergreifende Unterstützung.
3. Schreiben Sie C#-Skripte, um mit Webseiten zu interagieren, Daten zu extrahieren oder automatisierte Tests durchzuführen.

Beide Tools sind leistungsstark. PuppeteerSharp ist ideal für Chrome-zentrierte Aufgaben, während Selenium in browserübergreifenden Szenarien brilliert. Wählen Sie basierend auf den Anforderungen Ihres Projekts.

Selenium Headless Browser Testing in C# mit PhantomJS

Setup-Anforderungen

Das Einrichten eines Headless-Browsers in C# erfordert bestimmte Tools und Konfigurationen. Hier finden Sie eine Aufschlüsselung der erforderlichen Software und einen Vergleich von PuppeteerSharp und Selenium WebDriver.

Erforderliche Softwareinstallation

Für den Anfang benötigen Sie Folgendes:

• .NET-SDK: Installieren Sie es mit einer der folgenden Methoden:
  • Visual Studio Installer mit der ASP.NET-Workload
  • Visual Studio Code an. Nach der Installation können Sie HEIC-Dateien mit der C#-Entwicklungskit Erweiterung
  • Direkter Download von der .NET-Website
  • Befehlszeileninstallation über Windows-Paket-Manager (WinGet)
• Angebote: Installieren Sie die erforderlichen Pakete für Ihr Projekt:

Verpackung	Installationsbefehl	Zweck
PuppenspielerSharp	dotnet add package PuppeteerSharp	Automatisiert und steuert Chrome/Chromium
Selenium WebDriver	dotnet add package Selenium.WebDriver --version 4.29.0	Ermöglicht die Automatisierung mehrerer Browser
Browsertreiber	Laden Sie die erforderlichen Treiber für Ihren Browser herunter	Stellt die Funktionalität von Selenium sicher

Sobald die Software bereit ist, wollen wir untersuchen, wie PuppeteerSharp und Selenium WebDriver im Vergleich abschneiden.

PuppenspielerSharp vs Selenium WebDriver

Beide Tools eignen sich hervorragend für die Headless-Browserautomatisierung, dienen aber unterschiedlichen Zwecken. Hier ein kurzer Vergleich:

Merkmal	PuppenspielerSharp	Selenium WebDriver
Browser-Unterstützung	Beschränkt auf Chrome/Chromium	Funktioniert mit Chrome, Firefox, Edge usw.
Komplexität des Setups	Unkompliziert – inklusive automatischem Chromium-Download	Erfordert separate Treiberinstallation
Leistung	Optimiert für Chrome/Chromium	Einheitlich in allen unterstützten Browsern
API-Design	Modernes, versprechensbasiertes	Traditionell, objektorientiert
Memory Usage	Geringere Speichernutzung	Variiert je nach Browser

Für C#-Entwickler ist PuppeteerSharp oft am schnellsten einzurichten. Seine automatische Chromium-Verwaltung und die benutzerfreundliche API machen es ideal für Projekte, die sich ausschließlich auf Chrome/Chromium konzentrieren. Andererseits ist Selenium WebDriver besser für Projekte geeignet, die eine Browser-übergreifende Kompatibilität erfordern, da es mehrere Browser durch Ereignisse auf Betriebssystemebene und dedizierte Treiber unterstützt.

Um Chromium für PuppeteerSharp herunterzuladen, verwenden Sie den folgenden Code:

<span class="hljs-keyword">await</span> <span class="hljs-keyword">new</span> BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultChromiumRevision);

Dieses Setup stattet Sie mit den Tools aus, die Sie für eine robuste Headless-Browserautomatisierung benötigen, unabhängig davon, ob Sie an Test-Frameworks, Web Scraping oder der Automatisierung von Workflows arbeiten.

Erste Schritte mit PuppeteerSharp

PuppeteerSharp bietet eine leistungsstarke API zur Steuerung von Chrome oder Chromium im Headless-Modus und ist damit eine solide Wahl für C#-Web-Automatisierungsaufgaben.

Erster Browserstart

Nachdem Sie PuppeteerSharp über NuGet installiert haben, können Sie den Browser wie folgt einrichten und starten:

<span class="hljs-comment">// Ensure Chromium is downloaded using BrowserFetcher</span>
<span class="hljs-keyword">await</span> <span class="hljs-keyword">new</span> BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultChromiumRevision);

<span class="hljs-comment">// Launch the browser in headless mode</span>
<span class="hljs-keyword">var</span> launchOptions = <span class="hljs-keyword">new</span> LaunchOptions {
    Headless = <span class="hljs-literal">true</span>,
    Args = <span class="hljs-keyword">new</span>[] { <span class="hljs-string">"--no-sandbox"</span>, <span class="hljs-string">"--disable-setuid-sandbox"</span> }
};

<span class="hljs-keyword">using</span> <span class="hljs-keyword">var</span> browser = <span class="hljs-keyword">await</span> Puppeteer.LaunchAsync(launchOptions);
<span class="hljs-keyword">using</span> <span class="hljs-keyword">var</span> page = <span class="hljs-keyword">await</span> browser.NewPageAsync();

<span class="hljs-comment">// Navigate to a webpage</span>
<span class="hljs-keyword">await</span> page.GoToAsync(<span class="hljs-string">"https://example.com"</span>);

Nachdem Sie den Browser gestartet haben, können Sie mit der Interaktion mit Webseiten und dem Sammeln von Daten beginnen.

Seitenaktionen und Datenerfassung

Mit PuppeteerSharp können Sie verschiedene Aktionen auf Webseiten ausführen und Informationen extrahieren:

<span class="hljs-comment">// Enter text into an input field</span>
<span class="hljs-keyword">await</span> page.TypeAsync(<span class="hljs-string">"#search-input"</span>, <span class="hljs-string">"search term"</span>);

<span class="hljs-comment">// Click a button</span>
<span class="hljs-keyword">await</span> page.ClickAsync(<span class="hljs-string">"#submit-button"</span>);

<span class="hljs-comment">// Get text content from an element</span>
<span class="hljs-keyword">var</span> content = <span class="hljs-keyword">await</span> page.EvaluateExpressionAsync<<span class="hljs-built_in">string</span>>(<span class="hljs-string">"document.querySelector('.content').textContent"</span>);

<span class="hljs-comment">// Capture a screenshot</span>
<span class="hljs-keyword">await</span> page.ScreenshotAsync(<span class="hljs-string">"page-capture.png"</span>);

Für eine bessere Scraping-Leistung sollten Sie die folgenden Techniken in Betracht ziehen:

Technik	Wie umsetzen?	Vorteile
Abfangen von Anfragen	Blockieren Sie unnötige Ressourcen	Reduziert die Ladezeit
Zwischenspeichern von Assets	Verwenden eines benutzerdefinierten Benutzerdatenverzeichnisses	Beschleunigt wiederholte Besuche
Rate Limiting	Fügen Sie Verzögerungen zwischen Anfragen hinzu	Reduziert die Serverbelastung

Arbeiten mit dynamischen Inhalten

Statischer Inhalt ist unkompliziert, dynamischer Inhalt erfordert jedoch häufig zusätzliche Schritte, z. B. das Warten auf das Laden von Elementen oder die Verarbeitung von in JavaScript gerenderten Daten:

<span class="hljs-comment">// Wait for a specific element to appear</span>
<span class="hljs-keyword">await</span> page.WaitForSelectorAsync(<span class="hljs-string">".dynamic-content"</span>);

<span class="hljs-comment">// Wait for navigation to complete with network idle</span>
<span class="hljs-keyword">await</span> page.WaitForNavigationAsync(<span class="hljs-keyword">new</span> NavigationOptions {
    WaitUntil = <span class="hljs-keyword">new</span>[] { WaitUntilNavigation.NetworkIdle0 }
});

<span class="hljs-comment">// Extract text from dynamically loaded content</span>
<span class="hljs-keyword">var</span> dynamicContent = <span class="hljs-keyword">await</span> page.EvaluateFunctionAsync<<span class="hljs-built_in">string</span>>(<span class="hljs-string">@"() => {
    return document.querySelector('.js-content').innerText;
}"</span>);

Für komplexere Interaktionen, etwa beim Arbeiten mit Anwendungen wie Bing Maps, können Sie Aktionen verketten, um erweiterte, mit JavaScript gerenderte Inhalte zu verarbeiten.

Vergessen Sie nicht, Fehler zu behandeln und Timeouts festzulegen, um unerwartete Probleme zu vermeiden:

<span class="hljs-keyword">try</span> {
    <span class="hljs-keyword">await</span> page.WaitForSelectorAsync(<span class="hljs-string">".dynamic-element"</span>, <span class="hljs-keyword">new</span> WaitForSelectorOptions {
        Timeout = <span class="hljs-number">5000</span>
    });
} <span class="hljs-keyword">catch</span> (WaitTaskTimeoutException) {
    Console.WriteLine(<span class="hljs-string">"Element did not appear within 5 seconds"</span>);
}

Stellen Sie abschließend sicher, dass Sie die Ressourcen ordnungsgemäß bereinigen:

<span class="hljs-keyword">await</span> page.CloseAsync();
<span class="hljs-keyword">await</span> browser.CloseAsync();

Dieser Ansatz hält Ihre Automatisierung effizient und verhindert Speicherlecks.

sbb-itb-23997f1

Verwenden von Selenium WebDriver

Selenium WebDriver ist ein leistungsstarkes Tool zur Browserautomatisierung in C#. Im Gegensatz zu PuppeteerSharp, das sich auf Chrome konzentriert, unterstützt Selenium mehrere Browser und ist daher eine vielseitige Wahl für Tests.

Einrichten des Headless-Modus

Um Selenium WebDriver für den Headless-Modus zu konfigurieren, benötigen Sie browserspezifische Einstellungen. So richten Sie es für Chrome, Firefox und Edge ein:

<span class="hljs-comment">// Chrome setup</span>
<span class="hljs-keyword">var</span> chromeOptions = <span class="hljs-keyword">new</span> ChromeOptions();
chromeOptions.AddArgument(<span class="hljs-string">"--headless=new"</span>);
<span class="hljs-keyword">var</span> chromeDriver = <span class="hljs-keyword">new</span> ChromeDriver(chromeOptions);

<span class="hljs-comment">// Firefox setup</span>
<span class="hljs-keyword">var</span> firefoxOptions = <span class="hljs-keyword">new</span> FirefoxOptions();
firefoxOptions.Headless = <span class="hljs-literal">true</span>;
<span class="hljs-keyword">var</span> firefoxDriver = <span class="hljs-keyword">new</span> FirefoxDriver(firefoxOptions);

<span class="hljs-comment">// Edge setup</span>
<span class="hljs-keyword">var</span> edgeOptions = <span class="hljs-keyword">new</span> EdgeOptions();
edgeOptions.Headless = <span class="hljs-literal">true</span>;
<span class="hljs-keyword">var</span> edgeDriver = <span class="hljs-keyword">new</span> EdgeDriver(edgeOptions);

Wenn Sie Browser im Headless-Modus ausführen, können Sie Aufgaben wie die Interaktion mit Seitenelementen ohne sichtbare Benutzeroberfläche ausführen.

„Durch die Abschaffung der Convenience-Methode (und ihre Entfernung in Selenium 4.10.0) haben Benutzer die volle Kontrolle darüber, welchen Headless-Modus sie verwenden möchten.“ – Diego Molina, Selenium [2].

Erweiterte Seiteninteraktionen

Selenium WebDriver bewältigt mühelos detaillierte Webinteraktionen. Hier ist ein Beispiel für die Automatisierung gängiger Aufgaben:

<span class="hljs-comment">// Initialize WebDriverWait for explicit waits</span>
<span class="hljs-keyword">var</span> wait = <span class="hljs-keyword">new</span> WebDriverWait(driver, TimeSpan.FromSeconds(<span class="hljs-number">10</span>));

<span class="hljs-comment">// Wait for an element to become visible and interact with it</span>
<span class="hljs-keyword">var</span> element = wait.Until(ExpectedConditions.ElementIsVisible(By.Id(<span class="hljs-string">"dynamicElement"</span>)));
element.Click();

<span class="hljs-comment">// Handle alerts</span>
<span class="hljs-keyword">var</span> alert = driver.SwitchTo().Alert();
alert.Accept();

<span class="hljs-comment">// Work with frames</span>
driver.SwitchTo().Frame(<span class="hljs-string">"frameId"</span>);
<span class="hljs-keyword">var</span> frameElement = driver.FindElement(By.CssSelector(<span class="hljs-string">".frame-content"</span>));
driver.SwitchTo().DefaultContent();

Allgemeine Elementselektoren:

Selektortyp	Bester Anwendungsfall	Beispiel
ID	Einzigartige Elemente	By.Id("login-button")
CSS	Komplexe Muster	By.CssSelector(".nav > .item")
XPath	Dynamischer Inhalt	By.XPath("//div[contains(@class, 'dynamic')]")

Seitenexportoptionen

Selenium bietet mehrere Möglichkeiten, Seiteninhalte zu erfassen und zu exportieren. Hier sind einige Beispiele:

<span class="hljs-comment">// Take a full page screenshot</span>
<span class="hljs-keyword">var</span> screenshot = ((ITakesScreenshot)driver).GetScreenshotAs(ScreenshotImageFormat.Png);
screenshot.SaveAsFile(<span class="hljs-string">"page.png"</span>);

<span class="hljs-comment">// PDF export</span>
<span class="hljs-keyword">var</span> printOptions = <span class="hljs-keyword">new</span> PrintOptions()
{
    Orientation = PrintOrientation.Portrait,
    Scale = <span class="hljs-number">1.0</span>
};
driver.SavePrintPage(printOptions).SaveAsFile(<span class="hljs-string">"page.pdf"</span>);

<span class="hljs-comment">// Get page source</span>
<span class="hljs-keyword">var</span> htmlContent = driver.PageSource;
File.WriteAllText(<span class="hljs-string">"page.html"</span>, htmlContent);

Für eine reibungslose Automatisierung sind Timing-Konfigurationen unerlässlich:

<span class="hljs-comment">// Custom wait condition for page load</span>
wait.Until(driver => ((IJavaScriptExecutor)driver)
    .ExecuteScript(<span class="hljs-string">"return document.readyState"</span>).Equals(<span class="hljs-string">"complete"</span>));

<span class="hljs-comment">// Wait for a specific element to be present before exporting</span>
wait.Until(ExpectedConditions.ElementExists(By.CssSelector(<span class="hljs-string">".content-loaded"</span>)));

Stellen Sie abschließend sicher, dass die Ressourcen ordnungsgemäß bereinigt werden, wenn Sie fertig sind:

driver.Quit();
driver.Dispose();

Fehlerbehebung und Tipps

Geschwindigkeits- und Speicherverwaltung

Headless-Browser, wie sie in PuppeteerSharp verwendet werden, überspringen das Laden von CSS und sind dadurch schneller als herkömmliche Browser. Um diese Geschwindigkeit optimal zu nutzen und den Ressourcenverbrauch zu reduzieren, sollten Sie diese Optimierungen in Betracht ziehen:

<span class="hljs-keyword">var</span> launchOptions = <span class="hljs-keyword">new</span> LaunchOptions
{
    Headless = <span class="hljs-literal">true</span>,
    Args = <span class="hljs-keyword">new</span>[]
    {
        <span class="hljs-string">"--disable-gpu"</span>,
        <span class="hljs-string">"--disable-dev-shm-usage"</span>,
        <span class="hljs-string">"--disable-setuid-sandbox"</span>,
        <span class="hljs-string">"--no-sandbox"</span>,
        <span class="hljs-string">"--window-size=1920,1080"</span>
    }
};

<span class="hljs-comment">// Set a custom cache directory</span>
launchOptions.UserDataDir = <span class="hljs-string">"C:\\BrowserCache"</span>;

Sie können auch unnötige Ressourcen wie Bilder oder Stylesheets blockieren, um Speicherplatz zu sparen:

<span class="hljs-keyword">await</span> page.SetRequestInterceptionAsync(<span class="hljs-literal">true</span>);
page.Request += <span class="hljs-keyword">async</span> (sender, e) =>
{
    <span class="hljs-keyword">if</span> (e.Request.ResourceType == ResourceType.Document)
        <span class="hljs-keyword">await</span> e.Request.ContinueAsync();
    <span class="hljs-keyword">else</span>
        <span class="hljs-keyword">await</span> e.Request.AbortAsync();
};

Anleitung zur Fehlerbehebung

Eine Leistungsverbesserung ist großartig, aber für eine reibungslose Automatisierung ist es genauso wichtig, häufige Fehler zu beheben. Hier ist eine Kurzanleitung:

Fehlertyp	Gemeinsame Ursache	Lösung
Timeout-Ausnahmen	Langsames Laden der Seite	Verwenden Sie WebDriverWait mit längeren Timeouts.
Element nicht gefunden	Dynamischer Inhalt	Verwenden Sie explizite Wartezeiten und genaue Selektoren
Nichtübereinstimmung der Treiberversion	Veraltete Komponenten	Halten Sie WebDriver- und Browserversionen auf dem gleichen Stand

Mit diesem Code können Sie beispielsweise langsam ladende Seiten verarbeiten:

<span class="hljs-keyword">var</span> wait = <span class="hljs-keyword">new</span> WebDriverWait(driver, TimeSpan.FromSeconds(<span class="hljs-number">30</span>));
wait.Until(driver => ((IJavaScriptExecutor)driver)
    .ExecuteScript(<span class="hljs-string">"return document.readyState"</span>).Equals(<span class="hljs-string">"complete"</span>));

„Der Headless-Modus kann sich manchmal anders verhalten, da Rendering-Aspekte nicht sichtbar sind.“ – ClimbingLion [3].

Anmelde- und Sicherheitsschritte

Sobald die Fehler behoben sind, konzentrieren Sie sich auf eine sichere und zuverlässige Authentifizierung. Hier ist ein Beispiel für den sicheren Umgang mit Anmeldeinformationen:

<span class="hljs-comment">// Use environment variables for credentials</span>
<span class="hljs-keyword">var</span> username = Environment.GetEnvironmentVariable(<span class="hljs-string">"AUTH_USERNAME"</span>);
<span class="hljs-keyword">var</span> password = Environment.GetEnvironmentVariable(<span class="hljs-string">"AUTH_PASSWORD"</span>);

<span class="hljs-comment">// Apply rate limiting</span>
<span class="hljs-keyword">private</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">readonly</span> SemaphoreSlim _rateLimiter = <span class="hljs-keyword">new</span>(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
<span class="hljs-keyword">await</span> _rateLimiter.WaitAsync();
<span class="hljs-keyword">try</span>
{
    <span class="hljs-keyword">await</span> page.TypeAsync(<span class="hljs-string">"#username"</span>, username);
    <span class="hljs-keyword">await</span> page.TypeAsync(<span class="hljs-string">"#password"</span>, password);
    <span class="hljs-keyword">await</span> Task.Delay(<span class="hljs-number">1000</span>); <span class="hljs-comment">// Respect rate limits</span>
}
<span class="hljs-keyword">finally</span>
{
    _rateLimiter.Release();
}

Wichtige Sicherheitspraktiken, die Sie befolgen sollten:

• Verwenden Sie eine IP-basierte Ratenbegrenzung, um Missbrauch zu verhindern.
• Speichern Sie vertrauliche Informationen wie Anmeldeinformationen in Umgebungsvariablen.
• Stellen Sie eine ordnungsgemäße Sitzungsverwaltung sicher.
• Führen Sie regelmäßige Sicherheitsüberprüfungen durch.

Implementieren Sie zur Behandlung von Authentifizierungsfehlern eine Wiederholungslogik wie die folgende:

<span class="hljs-keyword">try</span>
{
    <span class="hljs-keyword">await</span> page.WaitForSelectorAsync(<span class="hljs-string">".login-success"</span>, 
        <span class="hljs-keyword">new</span> WaitForSelectorOptions { Timeout = <span class="hljs-number">5000</span> });
}
<span class="hljs-keyword">catch</span> (WaitTaskTimeoutException)
{
    <span class="hljs-comment">// Log the failed attempt and retry</span>
    <span class="hljs-keyword">await</span> page.ReloadAsync();
}

Fazit

Zusammenfassung

Die Headless-Browserautomatisierung in C# bietet leistungsstarke Optionen mit PuppenspielerSharp Selenium WebDriverWährend PuppeteerSharp für seine Geschwindigkeit und Effizienz mit Chrome/Chromium bekannt ist, zeichnet sich Selenium durch seine browserübergreifende Kompatibilität und Integrationen auf Unternehmensebene aus. [5]..

Hier ist eine kurze Aufschlüsselung:

• PuppenspielerSharp: Ideal für die Chrome/Chromium-Automatisierung, wenn Geschwindigkeit und Ressourceneffizienz Priorität haben [1]..
• Selen: Am besten geeignet für Aufgaben, die Kompatibilität mit mehreren Browsern und breitere Sprachunterstützung erfordern [4]..

„Puppeteer ist die bessere Wahl, wenn Geschwindigkeit und feinkörnige Browsersteuerung wichtig sind. Selenium unterstützt mehr Sprachen und ist besser geeignet, wenn Sie Ihre Scraping-Aufgaben über mehrere Browser hinweg ausführen müssen.“ – ZenRows [5].

Wenn Sie die Stärken dieser Tools kennen, können Sie das richtige für Ihre spezifischen Anforderungen und Projekte auswählen.

Weiteres Lernen

Wenn Sie Ihr Wissen über Headless-Browser in C# erweitern möchten, können diese Ressourcen hilfreich sein:

• TRETEN SIE DEM #puppenspieler-scharf Slack-Kanal für Echtzeit-Unterstützung [6]..
• Entdecken Sie unsere PuppeteerSharp.Beitrag Bibliothek für zusätzliche Funktionen [7]..
• Tauchen Sie ein in die offizielle API-Dokumentation um sich mit der gesamten Bandbreite der Möglichkeiten vertraut zu machen [6]..

Zu den praktischen Anwendungsgebieten dieser Werkzeuge gehören:

• Testen in CI/CD-Pipelines.
• Scraping dynamischer Webinhalte.
• Überwachung der Website-Leistung.
• Durchführen von UI-Tests in verschiedenen Browsern.

Die Headless-Browser-Landschaft entwickelt sich ständig weiter. Bleiben Sie auf dem Laufenden, indem Sie sich an GitHub-Projekten und Entwicklerforen beteiligen, um neue Updates und aufkommende Best Practices optimal zu nutzen.

Ähnliche Artikel

• Was ist ein Headless-Browser und warum brauchen Sie ihn?
• Node.js Headless Browser: Übersicht der besten Lösungen
• Headless Chrome: So verwenden und konfigurieren Sie es
• Headless-Browser mit Selenium verwenden: Setup und Codebeispiele