Navigateur sans tête en C# : configuration et exemples de code

Table des matières

Navigateur sans tête en C# : configuration et exemples de code

Les navigateurs headless vous permettent d'automatiser les tâches Web sans interface graphique. En C#, ils sont largement utilisés pour les tests, le scraping Web et la gestion de contenu. Deux outils populaires sont MarionnettisteAiguisé (optimisé pour Chrome/Chromium) et Pilote Web Selenium (prend en charge plusieurs navigateurs). Voici comment ils se comparent :

Fonctionnalité	MarionnettisteAiguisé	Pilote Web Selenium
Support du navigateur	Chrome / Chrome	Chrome, Firefox, Edge, etc.
Complexité de la configuration	Facile (téléchargement automatique de Chromium)	Nécessite une configuration de pilote distincte
Performances	Plus rapide pour Chrome/Chromium	Cohérent sur tous les navigateurs
Conception d'API	Moderne, basé sur des promesses	Traditionnel, orienté objet
Utilisation de la mémoire	Coût en adjuvantation plus élevé.	Varie selon le navigateur

Principaux avantages des navigateurs sans tête :

La vitesse: Tests plus rapides sans rendu GUI.
Rendement : Utilise moins de mémoire et de CPU.
Automation: Gère des tâches telles que la récupération de données, les tests et les soumissions de formulaires.

Pour une configuration rapide :

Installez l' SDK .NET et les packages requis (PuppeteerSharp or Selenium.WebDriver).
Utilisez PuppeteerSharp pour l’automatisation spécifique à Chrome ou Selenium pour la prise en charge multi-navigateurs.
Écrivez des scripts C# pour interagir avec des pages Web, extraire des données ou effectuer des tests automatisés.

Les deux outils sont puissants. PuppeteerSharp est idéal pour les tâches centrées sur Chrome, tandis que Selenium excelle dans les scénarios multi-navigateurs. Choisissez en fonction des besoins de votre projet.

Test du navigateur sans tête Selenium en C# avec PhantomJS

PhantomJS

Configuration requise

La configuration d'un navigateur headless en C# nécessite des outils et des configurations spécifiques. Voici une liste des logiciels nécessaires et une comparaison entre PuppeteerSharp et Selenium WebDriver.

Installation du logiciel requis

Pour commencer, vous aurez besoin des éléments suivants :

SDK .NET:Installez-le via l'une de ces méthodes :
- Visual Studio Installateur avec la charge de travail ASP.NET
- Visual Studio Code couplé à Kit de développement C# l'extension de
- Téléchargement direct depuis le site Web .NET
- Installation en ligne de commande via Gestionnaire de packages Windows (WinGet)
nos différents forfaits:Installez les packages requis pour votre projet :

Forfait	Commande d'installation	Objectif
MarionnettisteAiguisé	`dotnet add package PuppeteerSharp`	Automatise et contrôle Chrome/Chromium
Pilote Web Selenium	`dotnet add package Selenium.WebDriver --version 4.29.0`	Permet l'automatisation multi-navigateur
Pilotes de navigateur	Téléchargez les pilotes nécessaires pour votre navigateur	Assure la fonctionnalité de Selenium

Une fois le logiciel prêt, examinons comment PuppeteerSharp et Selenium WebDriver se comparent.

MarionnettisteAiguisé vs Pilote Web Selenium

MarionnettisteAiguisé

Ces deux outils sont excellents pour l'automatisation du navigateur headless mais servent à des fins différentes. Voici une comparaison rapide :

Fonctionnalité	MarionnettisteAiguisé	Pilote Web Selenium
Support du navigateur	Limité à Chrome/Chromium	Fonctionne avec Chrome, Firefox, Edge, etc.
Complexité de la configuration	Simple – inclut le téléchargement automatique de Chromium	Nécessite une installation de pilote séparée
Performances	Optimisé pour Chrome/Chromium	Cohérent sur tous les navigateurs pris en charge
Conception d'API	Moderne, basé sur des promesses	Traditionnel, orienté objet
Utilisation de la mémoire	Moins d'utilisation de la mémoire	Varie selon le navigateur

Pour les développeurs C#, PuppeteerSharp est souvent le plus rapide à configurer. Sa gestion automatique de Chromium et son API conviviale le rendent idéal pour les projets axés uniquement sur Chrome/Chromium. D'autre part, Selenium WebDriver est mieux adapté aux projets nécessitant une compatibilité entre navigateurs, car il prend en charge plusieurs navigateurs via des événements au niveau du système d'exploitation et des pilotes dédiés.

Pour télécharger Chromium pour PuppeteerSharp, utilisez le code suivant :

await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultChromiumRevision);

Cette configuration vous fournit les outils dont vous avez besoin pour une automatisation robuste du navigateur sans tête, que vous travailliez sur des frameworks de test, du scraping Web ou de l'automatisation des flux de travail.

Premiers pas avec PuppeteerSharp

PuppeteerSharp propose une API puissante pour contrôler Chrome ou Chromium en mode sans tête, ce qui en fait un choix solide pour les tâches d'automatisation Web C#.

Premier lancement du navigateur

Une fois que vous avez installé PuppeteerSharp via NuGet, vous pouvez configurer et lancer le navigateur comme ceci :

// Ensure Chromium is downloaded using BrowserFetcher
await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultChromiumRevision);

// Launch the browser in headless mode
var launchOptions = new LaunchOptions {
    Headless = true,
    Args = new[] { "--no-sandbox", "--disable-setuid-sandbox" }
};

using var browser = await Puppeteer.LaunchAsync(launchOptions);
using var page = await browser.NewPageAsync();

// Navigate to a webpage
await page.GoToAsync("https://example.com");

Après avoir lancé le navigateur, vous pouvez commencer à interagir avec les pages Web et à collecter des données.

Actions sur la page et collecte de données

PuppeteerSharp vous permet d'effectuer diverses actions sur les pages Web et d'extraire des informations :

// Enter text into an input field
await page.TypeAsync("#search-input", "search term");

// Click a button
await page.ClickAsync("#submit-button");

// Get text content from an element
var content = await page.EvaluateExpressionAsync<string>("document.querySelector('.content').textContent");

// Capture a screenshot
await page.ScreenshotAsync("page-capture.png");

Pour de meilleures performances de grattage, envisagez ces techniques :

Technique	Comment implémenter	Bénéfices
Demande d'interception	Bloquer les ressources inutiles	Réduit le temps de chargement
Mise en cache des ressources	Utiliser un répertoire de données utilisateur personnalisé	Accélère les visites répétées
Limitation du débit	Ajouter des délais entre les demandes	Réduit la pression sur le serveur

Travailler avec du contenu dynamique

Le contenu statique est simple, mais le contenu dynamique nécessite souvent des étapes supplémentaires, comme l'attente du chargement des éléments ou la gestion des données rendues par JavaScript :

// Wait for a specific element to appear
await page.WaitForSelectorAsync(".dynamic-content");

// Wait for navigation to complete with network idle
await page.WaitForNavigationAsync(new NavigationOptions {
    WaitUntil = new[] { WaitUntilNavigation.NetworkIdle0 }
});

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

Pour des interactions plus complexes, telles que l'utilisation d'applications comme Bing Maps, vous pouvez enchaîner des actions pour gérer du contenu avancé rendu par JavaScript.

N'oubliez pas de gérer les erreurs et de définir des délais d'attente pour éviter les problèmes inattendus :

try {
    await page.WaitForSelectorAsync(".dynamic-element", new WaitForSelectorOptions {
        Timeout = 5000
    });
} catch (WaitTaskTimeoutException) {
    Console.WriteLine("Element did not appear within 5 seconds");
}

Enfin, assurez-vous de nettoyer correctement les ressources :

await page.CloseAsync();
await browser.CloseAsync();

Cette approche maintient votre automatisation efficace et évite les fuites de mémoire.

sbb-itb-23997f1

Utilisation de Selenium WebDriver

Selenium WebDriver est un outil puissant pour l'automatisation du navigateur en C#. Contrairement à PuppeteerSharp, qui se concentre sur Chrome, Selenium prend en charge plusieurs navigateurs, ce qui en fait un choix polyvalent pour les tests.

Configuration du mode sans tête

Pour configurer Selenium WebDriver pour le mode headless, vous avez besoin de paramètres spécifiques au navigateur. Voici comment le configurer pour Chrome, Firefox et Edge :

// Chrome setup
var chromeOptions = new ChromeOptions();
chromeOptions.AddArgument("--headless=new");
var chromeDriver = new ChromeDriver(chromeOptions);

// Firefox setup
var firefoxOptions = new FirefoxOptions();
firefoxOptions.Headless = true;
var firefoxDriver = new FirefoxDriver(firefoxOptions);

// Edge setup
var edgeOptions = new EdgeOptions();
edgeOptions.Headless = true;
var edgeDriver = new EdgeDriver(edgeOptions);

L'exécution de navigateurs en mode sans tête vous permet d'effectuer des tâches telles que l'interaction avec des éléments de page sans interface utilisateur visible.

« En supprimant la méthode de commodité (et en la supprimant dans Selenium 4.10.0), les utilisateurs auront le contrôle total du choix du mode headless qu'ils souhaitent utiliser. » - Diego Molina, Selenium

Interactions avancées entre les pages

Selenium WebDriver gère les interactions Web détaillées sans effort. Voici un exemple d'automatisation des tâches courantes :

// Initialize WebDriverWait for explicit waits
var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));

// Wait for an element to become visible and interact with it
var element = wait.Until(ExpectedConditions.ElementIsVisible(By.Id("dynamicElement")));
element.Click();

// Handle alerts
var alert = driver.SwitchTo().Alert();
alert.Accept();

// Work with frames
driver.SwitchTo().Frame("frameId");
var frameElement = driver.FindElement(By.CssSelector(".frame-content"));
driver.SwitchTo().DefaultContent();

Sélecteurs d'éléments communs :

Type de sélecteur	Meilleur cas d'utilisation	Exemple
ID	Éléments uniques	`By.Id("login-button")`
CSS	Motifs complexes	`By.CssSelector(".nav > .item")`
XPath	Contenu dynamique	`By.XPath("//div[contains(@class, 'dynamic')]")`

Options d'exportation de pages

Selenium propose plusieurs méthodes pour capturer et exporter le contenu d'une page. Voici quelques exemples :

// Take a full page screenshot
var screenshot = ((ITakesScreenshot)driver).GetScreenshotAs(ScreenshotImageFormat.Png);
screenshot.SaveAsFile("page.png");

// PDF export
var printOptions = new PrintOptions()
{
    Orientation = PrintOrientation.Portrait,
    Scale = 1.0
};
driver.SavePrintPage(printOptions).SaveAsFile("page.pdf");

// Get page source
var htmlContent = driver.PageSource;
File.WriteAllText("page.html", htmlContent);

Les configurations de synchronisation sont essentielles pour une automatisation fluide :

// Custom wait condition for page load
wait.Until(driver => ((IJavaScriptExecutor)driver)
    .ExecuteScript("return document.readyState").Equals("complete"));

// Wait for a specific element to be present before exporting
wait.Until(ExpectedConditions.ElementExists(By.CssSelector(".content-loaded")));

Enfin, assurez-vous de bien nettoyer les ressources lorsque vous avez terminé :

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

Dépannage et astuces

Gestion de la vitesse et de la mémoire

Les navigateurs headless, comme ceux utilisés dans PuppeteerSharp, ignorent le chargement du CSS, ce qui les rend plus rapides que les navigateurs traditionnels. Pour tirer le meilleur parti de cette vitesse et réduire l'utilisation des ressources, envisagez ces optimisations :

var launchOptions = new LaunchOptions
{
    Headless = true,
    Args = new[]
    {
        "--disable-gpu",
        "--disable-dev-shm-usage",
        "--disable-setuid-sandbox",
        "--no-sandbox",
        "--window-size=1920,1080"
    }
};

// Set a custom cache directory
launchOptions.UserDataDir = "C:\\BrowserCache";

Vous pouvez également bloquer les ressources inutiles comme les images ou les feuilles de style pour économiser de la mémoire :

await page.SetRequestInterceptionAsync(true);
page.Request += async (sender, e) =>
{
    if (e.Request.ResourceType == ResourceType.Document)
        await e.Request.ContinueAsync();
    else
        await e.Request.AbortAsync();
};

Guide de correction des erreurs

Améliorer les performances est une bonne chose, mais corriger les erreurs courantes est tout aussi important pour une automatisation fluide. Voici un guide rapide :

Type d'erreur	Cause commune	Solution
Exceptions de dépassement de délai	Chargement lent des pages	Utilisez `WebDriverWait` avec des délais d'attente plus longs
Élément introuvable	Contenu dynamique	Utilisez des attentes explicites et des sélecteurs précis
Incompatibilité de version du pilote	Composants obsolètes	Gardez les versions de WebDriver et du navigateur alignées

Par exemple, vous pouvez utiliser ce code pour gérer les pages à chargement lent :

var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(30));
wait.Until(driver => ((IJavaScriptExecutor)driver)
    .ExecuteScript("return document.readyState").Equals("complete"));

« Le mode sans tête peut parfois se comporter différemment en raison d'aspects de rendu non visibles. » - ClimbingLion

Une fois les erreurs gérées, concentrez-vous sur une authentification sécurisée et fiable. Voici un exemple de gestion sécurisée des informations d'identification :

// Use environment variables for credentials
var username = Environment.GetEnvironmentVariable("AUTH_USERNAME");
var password = Environment.GetEnvironmentVariable("AUTH_PASSWORD");

// Apply rate limiting
private static readonly SemaphoreSlim _rateLimiter = new(1, 1);
await _rateLimiter.WaitAsync();
try
{
    await page.TypeAsync("#username", username);
    await page.TypeAsync("#password", password);
    await Task.Delay(1000); // Respect rate limits
}
finally
{
    _rateLimiter.Release();
}

Principales pratiques de sécurité à suivre :

Utilisez la limitation de débit basée sur IP pour éviter les abus.
Stockez les informations sensibles telles que les informations d’identification dans des variables d’environnement.
Assurer une bonne gestion des sessions.
Effectuer des contrôles de sécurité réguliers.

Pour gérer les erreurs d’authentification, implémentez une logique de nouvelle tentative comme ceci :

try
{
    await page.WaitForSelectorAsync(".login-success", 
        new WaitForSelectorOptions { Timeout = 5000 });
}
catch (WaitTaskTimeoutException)
{
    // Log the failed attempt and retry
    await page.ReloadAsync();
}

Conclusion

Résumé

L'automatisation du navigateur sans tête en C# offre des options puissantes avec MarionnettisteAiguisé et du Pilote Web SeleniumAlors que PuppeteerSharp est connu pour sa rapidité et son efficacité avec Chrome/Chromium, Selenium se distingue par sa compatibilité entre navigateurs et ses intégrations au niveau de l'entreprise. .

Voici une ventilation rapide:

MarionnettisteAiguisé:Idéal pour l'automatisation Chrome/Chromium lorsque la vitesse et l'efficacité des ressources sont des priorités .
Sélénium: Idéal pour les tâches nécessitant une compatibilité avec plusieurs navigateurs et une prise en charge linguistique plus large .

« Puppeteer est le meilleur choix lorsque la vitesse et le contrôle précis du navigateur sont essentiels. Selenium prend en charge davantage de langues et est plus adapté si vous devez exécuter vos tâches de scraping sur plusieurs navigateurs. » - ZenRows

En comprenant les points forts de ces outils, vous pouvez sélectionner celui qui convient le mieux à vos besoins et projets spécifiques.

Apprentissage supplémentaire

Si vous souhaitez approfondir vos connaissances sur les navigateurs headless en C#, ces ressources peuvent vous aider :

Rejoignez #marionnettiste-sharp Canal Slack pour une assistance en temps réel .
Jetez un coup d'œil au MarionnettisteSharp.Contrib bibliothèque pour des fonctionnalités supplémentaires .
Plongez dans l' documentation officielle de l'API pour vous familiariser avec l'ensemble des fonctionnalités .

Les applications pratiques de ces outils incluent :

Tests dans les pipelines CI/CD.
Récupération de contenu Web dynamique.
Suivi des performances du site Web.
Réalisation de tests d'interface utilisateur sur différents navigateurs.

Le paysage des navigateurs headless est en constante évolution. Restez informé en participant aux projets GitHub et aux forums de développeurs pour tirer le meilleur parti des nouvelles mises à jour et des meilleures pratiques émergentes.