Navigateur headless en C# : configuration et exemples de code

Les navigateurs headless vous permettent d’automatiser des 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 PuppeteerSharp (optimisé pour Chrome/Chromium) et Selenium WebDriver (compatible avec plusieurs navigateurs). Voici comment ils se comparent :

Principaux avantages des navigateurs headless :

• Rapidité : Tests plus rapides sans rendu de l’interface graphique.
• Efficacité : Consomme moins de mémoire et de processeur.
• Automatisation : Gère des tâches telles que le scraping de données, les tests et la soumission de formulaires.

Pour une configuration rapide :

1. Installez le SDK .NET et les packages requis (PuppeteerSharp ou Selenium.WebDriver).
2. Utilisez PuppeteerSharp pour l’automatisation spécifique à Chrome ou Selenium pour la compatibilité multi-navigateurs.
3. Écrivez des scripts C# pour interagir avec des pages web, extraire des données ou effectuer des tests automatisés.

Les deux outils sont performants. PuppeteerSharp est idéal pour les tâches centrées sur Chrome, tandis que Selenium excelle dans les contextes multi-navigateurs. Choisissez selon les besoins de votre projet.

Tests de navigateur headless Selenium en C# avec PhantomJS

Prérequis de configuration

La configuration d’un navigateur headless en C# implique des outils et des paramètres spécifiques. Voici un aperçu des logiciels nécessaires ainsi qu’une comparaison entre PuppeteerSharp et Selenium WebDriver.

Installation des logiciels requis

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

• SDK .NET : Installez-le avec l’une des méthodes suivantes :
  • Le programme d’installation Visual Studio avec la charge de travail ASP.NET
  • Visual Studio Code avec l’extension C# Dev Kit
  • Téléchargement direct depuis le site web de .NET
  • Installation en ligne de commande via Windows Package Manager (WinGet)
• Packages : Installez les packages requis pour votre projet :

Une fois les logiciels prêts, examinons comment PuppeteerSharp et Selenium WebDriver se comparent.

PuppeteerSharp vs Selenium WebDriver

Les deux outils sont excellents pour l’automatisation avec un navigateur headless, mais répondent à des besoins différents. Voici une comparaison rapide :

Pour les développeurs C#, PuppeteerSharp est souvent l’outil le plus rapide à configurer. Sa gestion automatique de Chromium et son API intuitive le rendent idéal pour les projets exclusivement axés sur Chrome/Chromium. À l’inverse, Selenium WebDriver convient mieux aux projets exigeant une compatibilité multi-navigateurs, car il prend en charge plusieurs navigateurs via des événements au niveau du système d’exploitation et des drivers dédiés.

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

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

Cette configuration vous fournit les outils nécessaires pour une automatisation robuste avec un navigateur headless, que vous travailliez sur des frameworks de test, du scraping web ou l’automatisation de workflows.

Premiers pas avec PuppeteerSharp

PuppeteerSharp offre une API puissante pour contrôler Chrome ou Chromium en mode headless, ce qui en fait un choix solide pour les tâches d’automatisation web en C#.

Premier lancement du navigateur

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

// 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 des pages web et à collecter des données.

Actions sur les pages et collecte de données

PuppeteerSharp vous permet d’effectuer diverses actions sur des 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 améliorer les performances du scraping, envisagez les techniques suivantes :

Utilisation de contenu dynamique

Le contenu statique est simple à gérer, mais le contenu dynamique nécessite souvent des étapes supplémentaires, comme attendre le chargement d’éléments ou traiter 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, comme avec des applications telles que Bing Maps, vous pouvez enchaîner les actions afin de gérer du contenu JavaScript avancé.

N’oubliez pas de gérer les erreurs et de définir des délais d’expiration 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, veillez à nettoyer correctement les ressources :

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

Cette approche maintient l’efficacité de votre automatisation et empêche les fuites de mémoire.

sbb-itb-23997f1

Utiliser Selenium WebDriver

Selenium WebDriver est un outil puissant d’automatisation de 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 headless

Pour configurer Selenium WebDriver en mode headless, vous devez appliquer des paramètres propres à chaque navigateur. Voici comment procéder 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 des navigateurs en mode headless vous permet d’effectuer des tâches telles que l’interaction avec les éléments d’une page sans interface utilisateur visible.

« En dépréciant la méthode de commodité (et en la supprimant dans Selenium 4.10.0), les utilisateurs auront un contrôle total pour choisir le mode headless qu’ils souhaitent utiliser. » - Diego Molina, Selenium [2]

Interactions avancées avec les pages

Selenium WebDriver gère facilement les interactions web détaillées. Voici un exemple d’automatisation de 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 courants :

Options d’exportation des pages

Selenium propose plusieurs moyens de capturer et d’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 temporisation 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 nettoyer correctement les ressources lorsque vous avez terminé :

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

Dépannage et conseils

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 pleinement parti de cette rapidité et réduire l’utilisation des ressources, envisagez les optimisations suivantes :

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, afin d’é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 résolution des erreurs

Améliorer les performances est utile, mais résoudre les erreurs courantes est tout aussi important pour assurer une automatisation fluide. Voici un guide rapide :

Par exemple, vous pouvez utiliser ce code pour gérer les pages qui se chargent lentement :

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

« Le mode headless peut parfois se comporter différemment, car certains aspects du rendu ne sont pas visibles. » - ClimbingLion [3]

Étapes de connexion et de sécurité

Une fois les erreurs maîtrisées, concentrez-vous sur une authentification sécurisée et fiable. Voici un exemple de gestion sécurisée des identifiants :

// 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 une limitation du débit basée sur l’adresse IP pour prévenir les abus.
• Stockez les informations sensibles, comme les identifiants, dans des variables d’environnement.
• Assurez une gestion appropriée des sessions.
• Effectuez régulièrement des revues de sécurité.

Pour gérer les erreurs d’authentification, mettez en œuvre une logique de nouvelle tentative comme suit :

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 de navigateur headless en C# offre des options puissantes avec PuppeteerSharp et Selenium WebDriver. Si PuppeteerSharp est reconnu pour sa rapidité et son efficacité avec Chrome/Chromium, Selenium se distingue par sa compatibilité multi-navigateurs et ses intégrations de niveau entreprise [5].

Voici une synthèse rapide :

• PuppeteerSharp : Idéal pour l’automatisation de Chrome/Chromium lorsque la rapidité et l’efficacité des ressources sont prioritaires [1].
• Selenium : Le plus adapté aux tâches nécessitant une compatibilité avec plusieurs navigateurs et une prise en charge plus étendue des langages [4].

« Puppeteer est le meilleur choix lorsque la rapidité et un contrôle précis du navigateur sont essentiels. Selenium prend en charge davantage de langages et convient mieux si vous devez exécuter vos tâches de scraping sur plusieurs navigateurs. » - ZenRows [5]

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

Pour aller plus loin

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

• Rejoignez le canal Slack #puppeteer-sharp pour obtenir une assistance en temps réel [6].
• Consultez la bibliothèque PuppeteerSharp.Contrib pour des fonctionnalités supplémentaires [7].
• Explorez la documentation officielle de l’API afin de vous familiariser avec l’ensemble des capacités disponibles [6].

Les applications pratiques de ces outils incluent :

• Les tests dans les pipelines CI/CD.
• Le scraping de contenu web dynamique.
• La surveillance des performances de sites web.
• L’exécution de tests d’interface utilisateur sur différents navigateurs.

L’écosystème des navigateurs headless évolue constamment. Restez à jour en participant aux projets GitHub et aux forums de développeurs afin de tirer pleinement parti des nouvelles mises à jour et des bonnes pratiques émergentes.