Remplacer le contrôle .NET WebBrowser par un meilleur navigateur, comme Chrome?

Existe-t-il un moyen relativement simple d'insérer un navigateur moderne dans une application .NET?

Pour autant que je comprends, le WebBrowsercontrôle est un wrapper pour IE , ce qui ne serait pas un problème sauf qu'il semble que ce soit une très ancienne version d' IE , avec tout ce que cela implique en termes de vissage CSS, de risques de sécurité potentiels (si le moteur de rendu n'a pas été corrigé, puis-je vraiment m'attendre à ce que les problèmes de débordement de tampon zillion soient résolus?), et d'autres problèmes.

J'utilise Visual Studio C # (édition express - cela fait-il une différence ici?)

Je souhaite intégrer un bon navigateur web dans mes applications. Dans certains, je l'utilise simplement pour gérer le processus d'enregistrement des utilisateurs, l'interface avec certaines des fonctionnalités de mon site Web et d'autres choses de cet ordre, mais j'ai une autre application en tête qui nécessitera plus de contrôle ...

J'ai besoin:

• Un navigateur qui peut s'intégrer dans une fenêtre de mon application (pas une fenêtre séparée)
• Un bon support pour CSS, js et autres technologies web, à la hauteur de tout navigateur moderne
• Fonctions de base du navigateur comme "naviguer", "retour", "recharger" ...
• Accès libéral au code de la page et à la sortie.

Je pensais à Chrome, car il est sous licence BSD, mais je serais tout aussi satisfait d'une version récente d'IE.

Autant que possible, je voudrais garder les choses simples. Le mieux serait de patcher l'existantWebBrowser contrôle , qui fait déjà environ 70% de ce dont j'ai besoin, mais je ne pense pas que ce soit possible.

J'ai trouvé un contrôle ActiveX pour Mozilla ( http://www.iol.ie/~locka/mozilla/control.htm ) mais il semble que ce soit une ancienne version, donc ce n'est pas nécessairement une amélioration.

Je suis ouvert aux suggestions

Checkout CefSharp .Net bindings, un projet que j'ai commencé il y a quelque temps qui a heureusement été repris par la communauté et transformé en quelque chose de merveilleux.

Le projet englobe le Chromium Embedded Framework et a été utilisé dans un certain nombre de projets majeurs, notamment le client Windows de Rdio, Facebook Messenger pour Windows et Github pour Windows.

Il propose des commandes de navigateur pour WPF et Winforms et dispose de tonnes de fonctionnalités et de points d'extension. Étant basé sur le chrome, il est également extrêmement rapide.

Récupérez-le dans NuGet: Install-Package CefSharp.WpfouInstall-Package CefSharp.WinForms

Découvrez des exemples et donnez vos réflexions / commentaires / demandes de traction: https://github.com/cefsharp/CefSharp

Licence BSD

Chrome utilise (une fourchette de) Webkit si vous ne le saviez pas, qui est également utilisé par Safari. Voici quelques questions du même ordre:

• Intégration de Webkit avec C #
• Intégration de Gecko (moteur Firefox) avec C #

Le webkit n'est pas génial comme le dit l'autre réponse, une version ne fonctionne plus (celle du code google) et la version mono est expérimentale. Ce serait bien si quelqu'un faisait l'effort de créer un wrapper .NET décent pour cela, mais ce n'est quelque chose que personne ne semble vouloir faire - ce qui est surprenant étant donné qu'il prend désormais en charge HTML5 et tant d'autres fonctionnalités que l'IE (8 ) le moteur manque.

Mise à jour (2014)

Il y a un nouveau projet sous double licence qui vous permet d'intégrer Chrome dans vos applications .NET appelé Awesomium . Il est livré avec une API .NET mais nécessite un certain nombre de hacks pour le rendu (les exemples dessinent la fenêtre du navigateur dans un tampon, peignent le tampon comme une image et actualisent sur une minuterie).

Je pense que c'est le navigateur utilisé par Origin dans Battlefield 3.

Mise à jour (2016)

Il existe maintenant DotnetBrowser , une alternative commerciale à Awesomium. Il est basé sur du chrome.

Je teste des alternatives au composant de navigateur Web C # depuis quelques jours maintenant et voici ma liste:

1. En utilisant les nouvelles versions IE 8,9:

Le composant Navigateur Web est IE7 et non IE8? Comment changer ça?

Avantages:

• Pas beaucoup de travail requis pour le faire fonctionner
• une prise en charge HTML5 / CSS3 si IE9, complète si IE10

Les inconvénients:

• La machine cible doit avoir la version IE cible installée, IE10 est toujours en préversion sur Win7

Cela ne nécessite pas beaucoup de travail et vous pouvez obtenir une prise en charge HTML5 et CSS3 bien qu'IE9 manque certaines des meilleures fonctionnalités CSS3 et HTML5. Mais je suis sûr que vous pouvez faire fonctionner IE10 de la même manière. Le problème serait que le système cible devrait avoir installé IE10, et comme il est toujours en préversion sur Windows 7, je le déconseille.

2. OpenWebKitSharp

OpenWebKitSharp est un wrapper .net pour le moteur webkit basé sur le projet WebKit.NET 0.5. WebKit est un moteur de mise en page utilisé par Chrome / Safari

Avantages:

• Développé activement
• Prise en charge HTML5 / CSS3

Les inconvénients:

• De nombreuses fonctionnalités non implémentées
• Ne prend pas en charge x64 (l'application doit être conçue pour x86)

OpenWebKit est assez sympa bien que de nombreuses fonctionnalités ne soient pas encore implémentées, j'ai rencontré quelques problèmes avec Visual Studio qui jette ici une référence d'objet nul puis en mode conception, il y a quelques problèmes js. Toute personne l'utilisant remarquera presque immédiatement que js alert ne fait rien. Les événements comme mouseup, mousedown ... etc. ne fonctionnent pas, js glisser-déposer est buggé et ainsi de suite ..

J'ai également eu quelques difficultés à l'installer car il nécessite une version spécifique de VC redistribuable installée, donc après exception, j'ai regardé le journal des événements, trouvé la version de VC et l'ai installé.

3. GeckoFX

Avantages:

• Fonctionne en mono
• Développé activement
• Prise en charge HTML5 / CSS3

Les inconvénients:

• Commentaires ci-dessous - voir les commentaires ci-dessous -

GeckoFX est un contrôle Webrowser multiplateforme pour l'intégration dans les applications WinForms. Cela peut être utilisé avec .NET sous Windows et avec mono sous Linux. Gecko est un moteur de mise en page utilisé par Firefox.

J'ai rencontré quelques informations selon lesquelles GeckoFX n'est pas activement développé, ce qui n'est pas vrai, bien sûr, il y a toujours une ou deux versions derrière Firefox, mais c'est normal, j'ai été vraiment impressionné par l'activité et le contrôle lui-même. Il fait tout ce dont j'avais besoin, mais j'avais besoin de temps pour le faire fonctionner, voici un petit tutoriel pour le faire fonctionner:

1. Téléchargez GeckoFx-Windows-16.0-0.2 , ici vous pouvez vérifier si le plus récent est disponible GeckoFX
2. Ajouter des références à deux DLL téléchargées
3. Puisque GeckoFX est un wrapper, vous avez besoin de XulRunner, accédez à la liste des versions pour voir celui dont vous avez besoin
4. Maintenant que nous savons de quelle version de XulRunner nous avons besoin, nous allons dans les versions de Mozilla XulRunner , allez dans le dossier version -> runtimes -> xulrunner- (your_version) .en-US.win32.zip, dans notre cas xulrunner-16.0.en- US.win32.zip
5. Décompressez tout et copiez tous les fichiers dans votre bin \ Debug (ou relâchez si votre projet est configuré pour sortir)
6. Allez dans Visual Studio Designer de votre formulaire, allez dans la boîte à outils, cliquez avec le bouton droit à l'intérieur -> Choisissez les éléments -> Parcourir -> Trouvez le fichier dll GeckoFX winforms téléchargé -> OK
7. Maintenant, vous devriez avoir un nouveau contrôle GeckoWebBrowser

Si vous devez vraiment utiliser Chrome, jetez un œil à ce produit appelé Awesomium , il est gratuit pour les projets non commerciaux, mais la licence est de quelques milliers de dollars pour les commerciaux.

J'ai eu le même problème, le WebBrowser utilisait une ancienne version d'IE, avec une recherche sur Google, je suis tombé sur le code suivant qui modifie le registre et oblige le WebBrowser à utiliser la dernière version d'IE possible:

 public enum BrowserEmulationVersion
    {
        Default = 0,
        Version7 = 7000,
        Version8 = 8000,
        Version8Standards = 8888,
        Version9 = 9000,
        Version9Standards = 9999,
        Version10 = 10000,
        Version10Standards = 10001,
        Version11 = 11000,
        Version11Edge = 11001
    }
    public static class WBEmulator
    {
        private const string InternetExplorerRootKey = @"Software\Microsoft\Internet Explorer";

        public static int GetInternetExplorerMajorVersion()
        {
            int result;

            result = 0;

            try
            {
                RegistryKey key;

                key = Registry.LocalMachine.OpenSubKey(InternetExplorerRootKey);

                if (key != null)
                {
                    object value;

                    value = key.GetValue("svcVersion", null) ?? key.GetValue("Version", null);

                    if (value != null)
                    {
                        string version;
                        int separator;

                        version = value.ToString();
                        separator = version.IndexOf('.');
                        if (separator != -1)
                        {
                            int.TryParse(version.Substring(0, separator), out result);
                        }
                    }
                }
            }
            catch (SecurityException)
            {
                // The user does not have the permissions required to read from the registry key.
            }
            catch (UnauthorizedAccessException)
            {
                // The user does not have the necessary registry rights.
            }

            return result;
        }
        private const string BrowserEmulationKey = InternetExplorerRootKey + @"\Main\FeatureControl\FEATURE_BROWSER_EMULATION";

        public static BrowserEmulationVersion GetBrowserEmulationVersion()
        {
            BrowserEmulationVersion result;

            result = BrowserEmulationVersion.Default;

            try
            {
                RegistryKey key;

                key = Registry.CurrentUser.OpenSubKey(BrowserEmulationKey, true);
                if (key != null)
                {
                    string programName;
                    object value;

                    programName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);
                    value = key.GetValue(programName, null);

                    if (value != null)
                    {
                        result = (BrowserEmulationVersion)Convert.ToInt32(value);
                    }
                }
            }
            catch (SecurityException)
            {
                // The user does not have the permissions required to read from the registry key.
            }
            catch (UnauthorizedAccessException)
            {
                // The user does not have the necessary registry rights.
            }

            return result;
        }
        public static bool SetBrowserEmulationVersion(BrowserEmulationVersion browserEmulationVersion)
        {
            bool result;

            result = false;

            try
            {
                RegistryKey key;

                key = Registry.CurrentUser.OpenSubKey(BrowserEmulationKey, true);

                if (key != null)
                {
                    string programName;

                    programName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);

                    if (browserEmulationVersion != BrowserEmulationVersion.Default)
                    {
                        // if it's a valid value, update or create the value
                        key.SetValue(programName, (int)browserEmulationVersion, RegistryValueKind.DWord);
                    }
                    else
                    {
                        // otherwise, remove the existing value
                        key.DeleteValue(programName, false);
                    }

                    result = true;
                }
            }
            catch (SecurityException)
            {
                // The user does not have the permissions required to read from the registry key.
            }
            catch (UnauthorizedAccessException)
            {
                // The user does not have the necessary registry rights.
            }

            return result;
        }

        public static bool SetBrowserEmulationVersion()
        {
            int ieVersion;
            BrowserEmulationVersion emulationCode;

            ieVersion = GetInternetExplorerMajorVersion();

            if (ieVersion >= 11)
            {
                emulationCode = BrowserEmulationVersion.Version11;
            }
            else
            {
                switch (ieVersion)
                {
                    case 10:
                        emulationCode = BrowserEmulationVersion.Version10;
                        break;
                    case 9:
                        emulationCode = BrowserEmulationVersion.Version9;
                        break;
                    case 8:
                        emulationCode = BrowserEmulationVersion.Version8;
                        break;
                    default:
                        emulationCode = BrowserEmulationVersion.Version7;
                        break;
                }
            }

            return SetBrowserEmulationVersion(emulationCode);
        }
        public static bool IsBrowserEmulationSet()
        {
            return GetBrowserEmulationVersion() != BrowserEmulationVersion.Default;
        }
    } 

Il vous suffit de créer une classe et d'y mettre ce code, puis d'exécuter le code suivant au démarrage du programme:

 if (!WBEmulator.IsBrowserEmulationSet())
            {
                WBEmulator.SetBrowserEmulationVersion();
            }

VB.NET:

Imports Microsoft.Win32
Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Linq
Imports System.Security
Imports System.Text
Imports System.Threading.Tasks

Public Enum BrowserEmulationVersion
    [Default] = 0
    Version7 = 7000
    Version8 = 8000
    Version8Standards = 8888
    Version9 = 9000
    Version9Standards = 9999
    Version10 = 10000
    Version10Standards = 10001
    Version11 = 11000
    Version11Edge = 11001
End Enum


Public Class WBEmulator
    Private Const InternetExplorerRootKey As String = "Software\Microsoft\Internet Explorer"
    Public Shared Function GetInternetExplorerMajorVersion() As Integer

        Dim result As Integer

        result = 0

        Try
            Dim key As RegistryKey
            key = Registry.LocalMachine.OpenSubKey(InternetExplorerRootKey)
            If key IsNot Nothing Then
                Dim value As Object = If(key.GetValue("svcVersion", Nothing), key.GetValue("Version", Nothing))

                Dim Version As String
                Dim separator As Integer
                Version = value.ToString()
                separator = Version.IndexOf(".")
                If separator <> -1 Then
                    Integer.TryParse(Version.Substring(0, separator), result)
                End If
            End If

        Catch ex As SecurityException
            'The user does Not have the permissions required to read from the registry key.
        Catch ex As UnauthorizedAccessException
            'The user does Not have the necessary registry rights.
        Catch

        End Try
        GetInternetExplorerMajorVersion = result
    End Function
    Private Const BrowserEmulationKey = InternetExplorerRootKey + "\Main\FeatureControl\FEATURE_BROWSER_EMULATION"

    Public Shared Function GetBrowserEmulationVersion() As BrowserEmulationVersion

        Dim result As BrowserEmulationVersion
        result = BrowserEmulationVersion.Default

        Try
            Dim key As RegistryKey = Registry.CurrentUser.OpenSubKey(BrowserEmulationKey, True)
            If key IsNot Nothing Then
                Dim programName As String
                Dim value As Object
                programName = Path.GetFileName(Environment.GetCommandLineArgs()(0))
                value = key.GetValue(programName, Nothing)
                If value IsNot Nothing Then
                    result = CType(Convert.ToInt32(value), BrowserEmulationVersion)
                End If
            End If
        Catch ex As SecurityException
            'The user does Not have the permissions required to read from the registry key.
        Catch ex As UnauthorizedAccessException
            'The user does Not have the necessary registry rights.
        Catch

        End Try

        GetBrowserEmulationVersion = result
    End Function
    Public Shared Function SetBrowserEmulationVersion(BEVersion As BrowserEmulationVersion) As Boolean

        Dim result As Boolean = False

        Try
            Dim key As RegistryKey = Registry.CurrentUser.OpenSubKey(BrowserEmulationKey, True)
            If key IsNot Nothing Then
                Dim programName As String = Path.GetFileName(Environment.GetCommandLineArgs()(0))
                If BEVersion <> BrowserEmulationVersion.Default Then
                    'if it's a valid value, update or create the value
                    key.SetValue(programName, CType(BEVersion, Integer), RegistryValueKind.DWord)
                Else
                    'otherwise, remove the existing value
                    key.DeleteValue(programName, False)
                End If
                result = True
            End If
        Catch ex As SecurityException

            ' The user does Not have the permissions required to read from the registry key.

        Catch ex As UnauthorizedAccessException

            ' The user does Not have the necessary registry rights.

        End Try

        SetBrowserEmulationVersion = result
    End Function


    Public Shared Function SetBrowserEmulationVersion() As Boolean
        Dim ieVersion As Integer
        Dim emulationCode As BrowserEmulationVersion
        ieVersion = GetInternetExplorerMajorVersion()

        If ieVersion >= 11 Then

            emulationCode = BrowserEmulationVersion.Version11
        Else

            Select Case ieVersion
                Case 10
                    emulationCode = BrowserEmulationVersion.Version10
                Case 9
                    emulationCode = BrowserEmulationVersion.Version9
                Case 8
                    emulationCode = BrowserEmulationVersion.Version8
                Case Else
                    emulationCode = BrowserEmulationVersion.Version7
            End Select
        End If

        SetBrowserEmulationVersion = SetBrowserEmulationVersion(emulationCode)
    End Function

    Public Shared Function IsBrowserEmulationSet() As Boolean
        IsBrowserEmulationSet = GetBrowserEmulationVersion() <> BrowserEmulationVersion.Default
    End Function
End Class

Vous pouvez l'utiliser comme:

If Not WBEmulator.IsBrowserEmulationSet() Then
    WBEmulator.SetBrowserEmulationVersion()
End If

Vous pouvez utiliser le registre pour définir la version d'IE pour le contrôle du navigateur Web. Accédez à: HKLM \ SOFTWARE \ Microsoft \ Internet Explorer \ Main \ FeatureControl \ FEATURE_BROWSER_EMULATION et ajoutez "yourApplicationName.exe" avec la valeur de browser_emulation Pour voir la valeur de browser_emulation, reportez-vous au lien: http://msdn.microsoft.com/en-us /library/ee330730%28VS.85%29.aspx#browser_emulation

Jetez un œil au contrôle Mono.WebBrowser - il intègre Gecko (tel qu'utilisé par Firefox) ou WebKit (tel qu'utilisé par Safari) dans WinForms (sans utiliser ActiveX).

Je sais que ce n'est pas un contrôle WebBrowser de `` remplacement '', mais j'avais de terribles problèmes de rendu lors de l'affichage d'une page qui utilisait BootStrap 3+ pour la mise en page, etc., puis j'ai trouvé un article qui m'a suggéré d'utiliser ce qui suit. Apparemment, il est spécifique à IE et lui dit d'utiliser la dernière variation trouvée sur la machine cliente pour le rendu (donc il n'utilisera pas IE7 comme je le crois par défaut)

Donc, mettez simplement:

<meta http-equiv="X-UA-Compatible" content="IE=Edge" />

quelque part dans la partie principale de votre document.

Si bien sûr ce n'est pas votre document, cela n'aidera évidemment pas (bien que je considère personnellement que c'est un trou de sécurité si vous lisez des pages non créées par vous-même via le contrôle webbrowser - pourquoi ne pas simplement utiliser un webbrowser!)

Bonne chance.

Jetez un œil au DotNetBrowser bibliothèque . Il fournit des contrôles de navigateur basés sur Chromium WPF et WinForms, qui sont assez faciles à intégrer dans une application .NET. Il prend en charge toutes les normes Web modernes, y compris HTML5, CSS3 et JavaScript. La page rendue ressemble exactement à Google Chrome.

La bibliothèque hérite de l'architecture multi-processus de Chromium - chaque page Web est rendue dans un processus Chromium distinct, et l'application continuera de fonctionner même après le plantage du plug-in ou toute autre erreur inattendue se produisant sur la page Web.

Voici quelques autres fonctionnalités utiles fournies par DotNetBrowser: il est possible d'écouter les événements de chargement, de gérer l'activité réseau, de configurer le proxy, de simuler les actions des utilisateurs, de travailler avec les cookies, d'accéder et de modifier le DOM, d'écouter les événements du DOM, d'appeler JavaScript depuis .NET et vice versa, utilisez la caméra Web et un microphone sur la page Web, mis en place une communication basée sur WebRTC, et plus .

Consultez la référence de l' API pour plus de détails.

L'extrait de code ci-dessous montre comment créer un BrowserView, l'intégrer dans un formulaire et charger une URL:

using System.Windows.Forms;
using DotNetBrowser;
using DotNetBrowser.WinForms;

namespace WinForms.DotNetBrowser
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            BrowserView browserView = new WinFormsBrowserView();
            Controls.Add((Control) browserView);
            browserView.Browser.LoadURL("http://www.youtube.com");
        }
    }
}

Une fois que vous avez exécuté l'exemple ci-dessus, vous obtiendrez la sortie suivante:

La bibliothèque est commerciale. Les licences commerciales incluent des packages de support pour différentes tailles d'équipe. Il est également possible d'acheter le code source de la bibliothèque.

Outre sa propre page, le composant est disponible sous forme de package NuGet et de package VSIX dans Visual Studio Marketplace.

J'ai essayé une poignée de variantes Webkit, mais d'après mon expérience, rien ne vaut les avancées d' OpenWebkitSharp . J'adore, j'adore. Les scores HTML5 et CSS3 sont aussi proches que possible de Google Chrome. Très bel API et modèle d'événementiel. Si vous trouvez des API "non implémentées" très probablement parce qu'elles ne sont pas implémentées dans Webkit. Tout le reste fonctionne très bien.

OpenWebKitSharp est un wrapper .net pour le moteur webkit basé sur le projet WebKit.NET 0.5. Il ajoute plus de fonctionnalités à la version 0.5 et fournit plus de méthodes que cette version. OpenWebKitSharp prend en charge à la fois la version Cairo (0.5) et les versions nightly de webkit (Nightly par défaut). Dans la version 1.5 Stable et plus, la construction nocturne est incluse et copiée automatiquement après la construction. Dans les versions antérieures, cela se produit avec la version cairo. OpenWebKitSharp alimente actuellement GTLite Navigator, un navigateur Web rapide, stable et flexible.

MISE À JOUR 2018 MAI

Si vous ciblez l'application pour qu'elle s'exécute sur Windows 10, vous pouvez désormais intégrer le navigateur Edge à votre application .net à l'aide de la Boîte à outils de la communauté Windows .

Exemple WPF:

1) Installez le package Nuget de la boîte à outils de la communauté Windows

Install-Package Microsoft.Toolkit.Win32.UI.Controls

2) Code XAML

<Window
    x:Class="WebViewTest.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:WPF="clr-namespace:Microsoft.Toolkit.Win32.UI.Controls.WPF;assembly=Microsoft.Toolkit.Win32.UI.Controls"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:local="clr-namespace:WebViewTest"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    Title="MainWindow"
    Width="800"
    Height="450"
    mc:Ignorable="d">
    <Grid>
        <WPF:WebView x:Name="wvc" />
    </Grid>
</Window>

3) Code CS:

public partial class MainWindow : Window
{
  public MainWindow()
  {
    InitializeComponent();

    // You can also use the Source property here or in the WPF designer
    wvc.Navigate(new Uri("https://www.microsoft.com"));
  }
}

Exemple WinForms:

public partial class Form1 : Form
{
  public Form1()
  {
    InitializeComponent();

    // You can also use the Source property here or in the designer
    webView1.Navigate(new Uri("https://www.microsoft.com"));
  }
}

Veuillez vous référer à ce lien pour plus d'informations.

Essayez EO.WebBrowser . Il est nouveau et basé sur la dernière version du navigateur Chrome. La meilleure partie à ce sujet est qu'il contient tout dans une seule DLL .NET, donc non seulement il est très facile à utiliser et à déployer, mais également la même DLL prend en charge les 32 bits et 64 bits car c'est une DLL .NET.

J'ai utilisé GeckoFX et cela me sert très bien. Il utilise le moteur Firefox. La seule mise en garde que j'ai jamais rencontrée avec lui, c'est qu'il émet l'événement "DocumentLoaded" une fois avant que le document ne soit réellement entièrement chargé ... Je pense qu'il en déclenche un lorsque le HTML est chargé, puis un autre lorsque tous les les images et les trucs sont chargés. Je l'ai corrigé en ignorant simplement le premier, et cela a fonctionné magnifiquement sans échec jusqu'à présent.

Vous pouvez le trouver ici: https://bitbucket.org/geckofx/

Comme la plupart des bibliothèques décentes, il est open-source.

MozNet est un contrôle .NET, précédemment basé sur le contrôle GeckoFX plus ou moins abandonné, mais est en plein développement et possède bien plus de fonctionnalités que GeckoFX ne peut le faire. Vous pouvez le trouver sur le site Web de Se7en Soft .

EO.BrowserControl est rapide et facile. Il a un moteur de navigateur Chrome et fonctionne avec n'importe quelle version de .NET

https://visualstudiogallery.msdn.microsoft.com/fcee0646-42e7-484f-b22e-f8b2ace55dd7

Remarque: Il s'agit d'un produit sous licence commerciale et je n'en fais pas la promotion dans cet esprit. Après avoir essayé diverses autres choses, j'ai fini par choisir cela.

Mise à jour 2016:

Il y a 3 options supplémentaires que je peux suggérer:

1. BrowseEmAll.Cef

Un composant .Net qui peut être utilisé pour intégrer le moteur Chrome dans votre application .Net. Basé sur CefGlue mais un peu plus rapide sur les mises à jour de la dernière version de Chrome. Il existe également une option de support commercial disponible qui pourrait être utile pour certains. Bien sûr, le composant lui-même est open source .

2. BrowseEmAll.Gecko

Un autre composant .Net qui peut être utilisé pour intégrer le moteur Firefox dans votre application .Net. Ceci est basé sur Geckofx mais contrairement à la version actuelle de Geckofx, cela fonctionnera avec une version normale de Firefox. Pour utiliser Geckofx, vous devrez créer Firefox vous-même. Encore une fois, un support commercial est disponible, mais le composant lui-même est entièrement open source .

3. API BrowseEmAll Core

Besoin de tous les différents navigateurs de votre application .Net? Quelle API BrowseEmAll Core vous pouvez intégrer Chrome, Firefox, Webkit et Internet Explorer dans votre application. Il s'agit d'un produit commercial, alors soyez averti.

(Divulgation complète: je travaille pour cette entreprise, alors prenez tout ce que je dis avec un grain de sel)

Webview2 - basé sur le chrome (aperçu) est maintenant disponible pour winform et wpf

Veuillez jeter un œil: https://docs.microsoft.com/en-us/microsoft-edge/webview2/

Si vous recherchez un bon contrôle basé sur IE - consultez: http://code.google.com/p/csexwb2/

Je l'ai utilisé dans des produits de production. Il est assez bon et propose de bonnes démos, bien qu'il ne semble pas être maintenu aussi bien qu'auparavant.

Geckofx et Webkit.net étaient tous deux prometteurs au début, mais ils ne se sont pas tenus à jour respectivement avec Firefox et Chrome tandis qu'Internet Explorer s'est amélioré, tout comme le contrôle Webbrowser, bien qu'il se comporte comme IE7 par défaut, quelle que soit la version d'IE que vous ont mais cela peut être corrigé en allant dans le registre et le changer en IE9 permettant HTML5.

Découvrez le contrôle GeckoFX .

J'ai essayé tous les navigateurs qui existent. Malheureusement, le seul qui a vraiment fonctionné pour moi en toutes circonstances était EO.Browser. Je souhaite que j'aurais pu choisir une solution gratuite, mais je me suis retrouvé avec EO.Browser. C'est assez cher, mais bien entretenu.

Mise à jour 2016:

Pour moi, la seule alternative de navigateur fiable et maintenue à IE est EO.WebBrowser. J'ai passé des jours et des semaines à essayer les autres. Tous ont eu des problèmes qui ont arrêté le spectacle pour moi à un moment donné.

Cela pourrait valoir la peine de jeter un œil à un produit commercial tel que WebKitX ici: https://www.webkitx.com

Il utilise Chromium Embedded Framework et rend HTML5, WebGL, PDF et Flash sur Windows XP, 7, 8, 10. Il fournit également des versions 32 bits et 64 bits du contrôle.

Il offre un accès DOM à l'aide d'objets COM similaires au contrôle IE WebBrowser:

Vous pouvez appeler JavaScript par nom de fonction en passant des arguments scalaires (sans utiliser eval) et il a également des rappels JavaScript pour Angular :

Vous pouvez ajouter vos propres objets COM interopérables à JavaScript:

Il prend en charge WebGL / WebAudio pour les jeux HTML5, que vous pouvez désactiver pour les environnements Citrix: