Note: Advice in this article will only work for DotNetBrowser 1.

Guia do Programador da DotNetBrowser

Introdução

A DotNetBrowser é uma Biblioteca .NET que permite a incorporação de um componente baseado em Chromium em aplicativos .NET para exibir páginas da Web modernas criadas com HTML5, CSS3, JavaScript, etc. A DotNetBrowser suporta os ambos subsistemas gráficos .NET tanto WPF como WinForms e fornece os componentes de interface do usuário WPF/WinForms que pode ser incorporado em Aplicativo de Desktop .NET para exibir páginas da web.

Chromium

Todos os binários Chromium necessários são incorporados com a biblioteca. Você não precisa instalar o Google Chrome para trabalhar com a DotNetBrowser. A DotNetBrowser usa Chromium 51.0.2704.106.

Renderização

Tudo que você vê na página da Web, quando você carregá-la, é processado pelo motor Chromium. A DotNetBrowser exibe apenas as partes da página da web processadas pelo motor Chromium. O Chromium carrega e processa páginas da web em processos separados nativos (Arquitetura de Multiprocessamento). A página web parece exatamente como no Google Chrome.

Arquitetura de Multiprocessamento

A DotNetBrowser herda Arquitetura de Multiprocessamento do Chromium. Cada página da web é processada em um processo separado nativo (DotNetBrowser.Chromium.exe). JavaScript na página web e plugins são executados em processos separados nativas também. Se um erro inesperado acontecer no plug-in da página Web ou DOM, o aplicativo continuará funcionando. Você pode ouvir eventos sobre encerramento inesperado do processo Chromium e restaurar componente Navegador, se necessário.

Uso da Memória

Desde toda a funcionalidade do Chromium está sendo executado em processos nativos separados, motor Chromium não usa a memória de seu aplicativo .NET.

Instalação e Implantação

Requisitos

A DotNetBrowser funciona no Windows, de 32 e 64 bits:

Microsoft Windows

• Windows 10
• Windows 8 & 8.1
• Windows 7
• Windows Server 2008
• Windows Server 2012

Microsoft Visual Studio

• 2013
• 2015

.NET Framework

• 4.0 ou superior

Instalação

A DotNetBrowser é distribuído como um simples arquivo ZIP dotnetbrowser-x.x.x.zip. O arquivo tem a seguinte estrutura:

• Biblioteca DotNetBrowser (/Library/DotNetBrowser.dll)
• DotNetBrowser Chromium binários para Windows (/Library/DotNetBrowser.Chromium.dll)
• Especificação da API da DotNetBrowser (/Library/Documentation/API/)
• Exemplos DotNetBrowser (/Samples)
• Aplicação Demo DotNetBrowser (/Library/DotNetBrowser.WPF.Demo.exe e /Library/WindowsForms.Demo.exe)
• Acordo de Licença DotNetBrowser (Licence Agreement.txt)
• Readme file (Readme.txt)
• Requisitos de software e hardware (Requirements.txt)
• Licença Chromium WebKit (GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1.txt e GNU LIBRARY GENERAL PUBLIC LICENSE - Version 2.txt.txt)

Para incluir a DotNetBrowser em seu Microsoft Visual Studio, você precisa baixar e extrair o arquivo em algum diretório, e adicionar a referência para DotNetBrowser.dll e DotNetBrowser.Chromium.dll em seu .NET do projeto no Visual Studio 2013.

Licenciamento

Para trabalhar com a biblioteca DotNetBrowser, você precisa de um arquivo de licença — teamdev.licenses. Existem dois tipos de licenças: avaliação de teste grátis por 30 dias e licença comercial.

Licença de Avaliação de 30 dias

Quando você solicita um arquivo de licença de avaliação de 30 dias, você receberá uma mensagem de e-mail com o link de download para o arquivo teamdev.licenses. Para ativar a licença de avaliação, você precisa incluir o arquivo em seu projeto MS VS2013 como Recurso Incorporado.

Licença Comercial

Quando você comprar uma licença comercial, você tem um arquivo com dois arquivos de licença dentro:

Development/
    teamdev.licenses
Runtime/
    teamdev.licenses

Você precisa incluir um desses arquivos de licença em seu projeto no Visual Studio para ativar a licença. A diferença entre as licenças de Desenvolvimento e de Tempo de Execução é o seguinte:

• você precisa usar a Licença de Desenvolvimento apenas para fins de desenvolvimento. O número de licenças deve ser igual ao número de desenvolvedores que usam a DotNetBrowser no desenvolvimento. Por exemplo, se você tiver 10 desenvolvedores envolvidos em seu projeto e apenas 4 deles trabalham com a DotNetBrowser, você deve comprar apenas 4 licenças.
• a Licença de Tempo de Execução deve ser usada quando você distribuir seu software com a DotNetBrowser fechada. Você pode implantar a Licença de Tempo de Execução com o seu pedido para um número ilimitado de usuários finais.

Implantação

Aqui está uma lista dos arquivos necessários que devem ser implantados para o ambiente do usuário final:

A maneira de implantar esses arquivos depende de você.

Introdução

Em geral, para começar a trabalhar com a biblioteca DotNetBrowser no seu aplicativo .NET você precisa:

1. Incluir DotNetBrowser.dll em seu projeto do Visual Studio.
2. Include teamdev.licenses into your Visual Studio Project as Recurso Incorporado.

Instalação de Licença de Avaliação

Navegador

Usando instância da DotNetBrowser.Browser você pode trabalhar com o motor Chromium. Essa interface fornece métodos para o carregamento de páginas web por URL, carregamento de conteúdo HTML, obtenção de conteúdo HTML da página web carregada, executar JavaScript, navegar através de histórico de navegação, acessar a carregamento de Navegador, eventos de status, etc.

A biblioteca DotNetBrowser define todas as classes e interfaces nos seguintes espaço de nomes:

DotNetBrowser
DotNetBrowser.Events
DotNetBrowser.WPF
DotNetBrowser.WinForms

Quando você não precisa usar a instância Browser você deve dispor-o usando o método da Browser.Dispose(). Este método lança todos os alocados recursos por instância e termina todos os processos nativos correspondentes.

C#

if (!browser.Disposed)
{
    browser.Dispose();
}

VB.NET

If Not browser.Disposed Then
    browser.Dispose()
End If

A instância Browser pode ser eliminada do código JavaScript através da função window.close() JavaScript. Para receber notificações sobre a utilização de disposição de instância DisposeEvent:

browser.DisposeEvent += delegate(object sender, DisposeEventArgs e){};

AddHandler browser.DisposeEvent, sub(ByVal sender As Object, ByVal e As DisposeEventArgs)
End sub

BrowserFactory

Para criar a instância Browser utilize o método da BrowserFactory.Create().

C#

using DotNetBrowser;

Browser browser = BrowserFactory.Create();

VB.NET

Imports DotNetBrowser

Dim browser As Browser = BrowserFactory.Create()

BrowserContext

Cada instância ‘Browser’ deve ser criada usando a BrowserFactory. A ‘BrowserFactory’ Inicializa o contexto necessário para uma sessão de navegação e fornece o caminho para o diretório onde o Chromium armazena cookies, arquivos de dados de cache, etc.

O código a seguir cria uma nova instância do Browser inicializada com contexto padrão:

C#

Browser browser = BrowserFactory.Create();

VB.NET

Dim browser As Browser = BrowserFactory.Create()

O código acima é igual a:

C#

Browser browser = BrowserFactory.Create(BrowserContext.DefaultContext);

VB.NET

Dim browser As Browser = BrowserFactory.Create(BrowserContext.DefaultContext)

A propriedade da BrowserContext.DefaultContext é um padrão da BrowserContext que é configurado para armazenar arquivos de dados do Chromium como cookies, cache, etc. no diretório temporário do usuário. Você pode obter o caminho para o diretório onde os arquivos de dados são armazenados usando o método BrowserPreferences.GetDefaultDataDir().

Duas instâncias ‘Browser’ com mesma a ‘BrowserContext’ usarão o mesmo diretório de dados do usuário. Como resultado, eles compartilham os cookies e arquivos de cache. Por exemplo:

C#

BrowserContextParams params1= new BrowserContextParams("C:\my-data1");
BrowserContext context1 = new BrowserContext(params1);
Browser browser1 = BrowserFactory.Create(context1);
Browser browser2 = BrowserFactory.Create(context1);

VB.NET

Dim params1 As BrowserContextParams = New BrowserContextParams("C:my-data1")
Dim context1 As BrowserContext = New BrowserContext(params1)
Dim browser1 As Browser = BrowserFactory.Create(context1)
Dim browser2 As Browser = BrowserFactory.Create(context1)

Para criar instâncias ‘Browser’ independentes que não compartilham os cookies e cache de dados, você deve inicializar cada instância do Browser com uma diferente BrowserContext configurado para usar diferentes diretórios de dados. Por exemplo:

C#

BrowserContextParams params1= new BrowserContextParams("C:\my-data1");
BrowserContext context1 = new BrowserContext(params1);
Browser browser1 = BrowserFactory.Create(context1);

BrowserContextParams params2= new BrowserContextParams("C:\my-data2");
BrowserContext context2 = new BrowserContext(params2);
Browser browser2 = BrowserFactory.Create(context2);

VB.NET

Dim params1 As BrowserContextParams = New BrowserContextParams("C:\my-data1")
Dim context1 As BrowserContext = New BrowserContext(params1)
Dim browser1 As Browser = BrowserFactory.Create(context1)

Dim params2 As BrowserContextParams = New BrowserContextParams("C:\my-data2")
Dim context2 As BrowserContext = New BrowserContext(params2)
Dim browser2 As Browser = BrowserFactory.Create(context2)

Para obter a BrowserContext da instância Browser você pode usar a propriedade da browser.Context.

 Make sure that you don't use several BrowserContext instances configured to use same data directory.
 In this case Chromium engine will read/write same data directory from different Browser instances which might cause unexpected behavior or errors.

BrowserView

BrowserView representa uma interface para os componentes de interface do usuário que podem ser incorporados em aplicativos .NET GUI para exibir conteúdo HTML. A DotNetBrowser fornece duas implementações da BrowserView: WPFBrowserView e WinFormsBrowserView.

Eliminação da BrowserView

Para a BrowserView, você primeiro precisa eliminar a visão e depois seu navegador:

C#

browserView.Dispose();
browserView.Browser.Dispose();

VB.NET

browserView.Dispose()
browserView.Browser.Dispose()

O lugar habitual para descarte da BrowserView é o evento de FormClosing para WinForms e evento de Window.Closing para WPF.

A BrowserView criada através de seu construtor padrão descarta-se automaticamente.

BrowserView - WinForms

O exemplo de código a seguir demonstra como criar uma instância WinForms Browser, incorporá-la em uma janela e carregar o URL http://www.google.com. Mais detalhes sobre como configurar a amostra podem ser encontrados na Quick Start Guide.

C#

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.google.com“);
   }
 }
}

VB.NET

Imports System.Windows.Forms
Imports DotNetBrowser
Imports DotNetBrowser.WinForms

Namespace WinForms.DotNetBrowser
    Public Partial Class Form1
        Inherits Form

        Public Sub New()
            InitializeComponent()
            Dim browserView As BrowserView = New WinFormsBrowserView()
            Controls.Add(CType(browserView, Control))
            browserView.Browser.LoadURL("http://www.google.com")
        End Sub
    End Class
End Namespace

BrowserView - WPF

O seguinte código de exemplo demonstra como criar uma instância do Navegador WPF, incorporá-la em uma janela e carregar o URL http://www.google.com. Mais detalhes sobre a configuração da amostra podem ser encontrados na Quick Start Guide.

MainWindow.xaml

<Window x:Class="WPF.DotNetBrowser.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid Name="mainLayout">

    </Grid>
</Window>

C#

MainWindow.xaml.cs

using DotNetBrowser;
using DotNetBrowser.WPF;

namespace WPF.DotNetBrowser
{
    public partial class MainWindow : Window
    {
        BrowserView webView;
        public MainWindow()
        {
            InitializeComponent();
            webView = new WPFBrowserView(BrowserFactory.Create());
            mainLayout.Children.Add((UIElement)webView.GetComponent());
            webView.Browser.LoadURL("http://www.google.com");
        }
    }
}

VB.NET

MainWindow.xaml.vb

Imports DotNetBrowser
Imports DotNetBrowser.WPF

Namespace WPF.DotNetBrowser
    Public Partial Class MainWindow
        Inherits Window

        Private webView As BrowserView

        Public Sub New()
            InitializeComponent()
            webView = New WPFBrowserView(BrowserFactory.Create())
            mainLayout.Children.Add(CType(webView.GetComponent(), UIElement))
            webView.Browser.LoadURL("http://www.google.com")
        End Sub
    End Class
End Namespace

Renderização Leve e Pesado

A DotNetBrowser suporta dois modos de renderização: leve e pesado. Por padrão, o modo de processamento pesado é ativada, por isso, quando você cria a instância Browser usando o seguinte código, isso cria uma nova instância Browser configurada para usar o modo de renderização pesado:

C#

Browser browser = BrowserFactory.Create();

VB.NET

Dim browser As Browser = BrowserFactory.Create()

Para criar uma nova instância do Navegador com o modo de renderização especificada use a seguinte forma:

C#

// Creates Browser instance with enabled lighweight rendering mode
Browser browser = BrowserFactory.Create(BrowserType.LIGHTWEIGHT);

// Creates Browser instance with enabled heavyweight rendering mode
Browser browser = BrowserFactory.Create(BrowserType.HEAVYWEIGHT);

VB.NET

' Creates Browser instance with enabled lighweight rendering mode
Dim browser As Browser = BrowserFactory.Create(BrowserType.LIGHTWEIGHT)

' Creates Browser instance with enabled heavyweight rendering mode
Dim browser As Browser = BrowserFactory.Create(BrowserType.HEAVYWEIGHT)

As diferenças entre os modos de renderização leve e pesado e recomendações sobre o modo de renderização que você deve usar em sua aplicação você pode encontrar a seguir:

Carregamento de URL

Para carregar uma página da Web pelo seu URL usam o método de Browser.LoadURL().

O seguinte código demonstra como carregar a página da Web http://www.google.com:

C#

browser.LoadURL("http://www.google.com");

VB.NET

browser.LoadURL("http://www.google.com")

A página da Web vai se carregar assincronamente (isso não bloqueia o encadeamento de execução corrente), então não há garantia que a página da Web do Google se carregará completamente quando o método volta. Para saber quando a página da Web é carregada completamente use o Carregar Eventos.

Desde 1.8.1 é possível determinar quando navegador está carregando alguma coisa. A propriedade Browser.Loading voltará verdade neste caso.

C#

using System;
using DotNetBrowser;

namespace MyNamespace
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create Browser instance.
            Browser browser = BrowserFactory.Create();

            // Load "http://www.google.com" URL
            browser.LoadURL("http://www.google.com");

            // Dispose Browser instance.
            browser.Dispose();
        }
    }
}

VB.NET

Imports System
Imports DotNetBrowser

Namespace MyNamespace
    Class Program
        Private Shared Sub Main(ByVal args As String())
            ' Create Browser instance.
            Dim browser As Browser = BrowserFactory.Create()
            ' Load "http://www.google.com" URL.
            browser.LoadURL("http://www.google.com")
            ' Dispose Browser instance.
            browser.Dispose()
        End Sub
    End Class
End Namespace

Carregamento e Espera

Em alguns casos (p. ex. testes de automação) precisaria de bloquear o encadeamento de execução corrente e esperar até que a página da Web se carregue completamente.

O exemplo de código a seguir demonstra como carregar a página da web http://www.google.com e esperar até que ela é carregada completamente:

C#

ManualResetEvent waitEvent = new ManualResetEvent(false);
browser.FinishLoadingFrameEvent += delegate(object sender, FinishLoadingEventArgs e)
{
    // Wait until main document of the web page is loaded completely.
    if (e.IsMainFrame)
    {
        waitEvent.Set();
    }
};
browser.LoadURL("http://www.google.com");
waitEvent.WaitOne();

VB.NET

Dim waitEvent As ManualResetEvent = New ManualResetEvent(False)
AddHandler browser.FinishLoadingFrameEvent, sub(ByVal sender As Object, ByVal e As FinishLoadingEventArgs)

    If e.IsMainFrame Then
        waitEvent.Set()
    End If
End sub

browser.LoadURL("http://www.google.com")
waitEvent.WaitOne()

Configuração de Manipulador de Carga

LoadHandler permite a manipulação de qualquer atividade de carga, incluindo a filtragem de todos os URLs carregados no Componente de Navegador. Usando o LoadHandler você pode cancelar qualquer evento de carga ou suprimir os certificados SSL problemáticos.

Exemplo:

C#

using System;
using DotNetBrowser;
using DotNetBrowser.Events;

namespace MyNamespace
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create Browser instance.
            Browser browser = BrowserFactory.Create();
            // Register custom LoadHandler implementation.
            browser.LoadHandler = new MyLoadHandler();
            // Load "http://www.google.com" URL.
            browser.LoadURL("http://www.google.com");
            // Dispose Browser instance.
            browser.Dispose();
        }
    }

    public class MyLoadHandler : DefaultLoadHandler
    {
        public override bool OnLoad(LoadParams loadParams)
        {
            // Suppress loading everything with URL that starts with "http://www.google.com".
            if (loadParams.Url.StartsWith("http://www.google.com"))
            {
                return true;
            }
            return false;
        }
    }
}

VB.NET

Imports DotNetBrowser

Namespace MyNamespace
    Class Program
        Private Shared Sub Main(ByVal args As String())
            ' Create Browser instance.
            Dim browser As Browser = BrowserFactory.Create()
            ' Register custom LoadHandler implementation.
            browser.LoadHandler = New MyLoadHandler()
            ' Load "http://www.google.com" URL.
            browser.LoadURL("http://www.google.com")
            ' Dispose Browser instance.
            browser.Dispose()
        End Sub
    End Class

    Public Class MyLoadHandler
        Inherits DefaultLoadHandler

        Public Overrides Function OnLoad(ByVal loadParams As LoadParams) As Boolean
            ' Suppress loading everything with URL that starts with "http://www.google.com".
            If loadParams.Url.StartsWith("http://www.google.com") Then
                Return True
            End If

            Return False
        End Function
    End Class
End Namespace

Ativar/Desativar Navegação Backspace

Por padrão a navegação Backspace e Shift+Backspace está ativada. Para desativar a navegação quando o usuário pressiona Backspace ou Shift+Backspace use a seguinte aproximação:

MainWindow.xaml

<Window x:Class="WPF.BackspaceNavigation.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525" Closing="Window_Closing">
    <Grid Name="mainLayout">

    </Grid>
</Window>

C#

MainWindow.xaml.cs

using System;
using System.IO;
using DotNetBrowser;
using DotNetBrowser.WPF;
using System.Windows;

namespace WPF.BackspaceNavigation
{
    public partial class MainWindow : Window
    {
        Browser browser;
        WPFBrowserView browserView;

        public MainWindow()
        {
            InitializeComponent();
            browser = BrowserFactory.Create();
            browserView = new WPFBrowserView(browser);
            mainLayout.Children.Add(browserView);
            browser.LoadHandler = new SampleLoadHandler();
            browserView.Browser.LoadURL("http://www.google.com");
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            // Dispose BrowserView when close app window.
            browserView.Dispose();
            browser.Dispose();
        }
    }

    class SampleLoadHandler : DefaultLoadHandler
    {
        public override bool CanNavigateOnBackspace()
        {
            return false;
        }
    }
}

VB.NET

MainWindow.xaml.vb

Imports DotNetBrowser
Imports DotNetBrowser.WPF

Namespace WPF.BackspaceNavigation
    Public Partial Class MainWindow
        Inherits Window

        Private browser As Browser
        Private browserView As WPFBrowserView

        Public Sub New()
            InitializeComponent()
            browser = BrowserFactory.Create()
            browserView = New WPFBrowserView(browser)
            mainLayout.Children.Add(browserView)
            browser.LoadHandler = New SampleLoadHandler()
            browserView.Browser.LoadURL("http://www.google.com")
        End Sub

        Private Sub Window_Closing(ByVal sender As Object, ByVal e As System.ComponentModel.CancelEventArgs)
            browserView.Dispose()
            browser.Dispose()
        End Sub
    End Class

    Class SampleLoadHandler
        Inherits DefaultLoadHandler

        Public Overrides Function CanNavigateOnBackspace() As Boolean
            Return False
        End Function
    End Class
End Namespace

Carregamento de conteúdo HTML

Para carregar conteúdo HTML a partir de uma cadeia de caracteres use o método Browser.LoadHTML(). Por exemplo:

C#

browser.LoadHTML("<html><body><h1>Load HTML Sample</h1></body></html>");

VB.NET

browser.LoadHTML("<html><body><h1>Load HTML Sample</h1></body></html>")

A saída será semelhante a este:

Exemplo

C#

using System;
using DotNetBrowser;

namespace MyNamespace
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create Browser instance.
            Browser browser = BrowserFactory.Create();

            // Load HTML content from string .
            browser.LoadHTML("<html><body><h1>Load HTML Sample</h1></body></html>");
            
            // Dispose Browser instance.
            browser.Dispose();
        }
    }
}

VB.NET

Imports DotNetBrowser

Module Module1
    Sub Main(args As String())
        ' Create Browser instance.
        Dim browser As Browser = BrowserFactory.Create()
        ' Load HTML content from string.
        browser.LoadHTML("<html><body><h1>Load HTML Sample</h1></body></html>")
        ' Dispose Browser instance.
        browser.Dispose()
    End Sub
End Module

Recebendo HTML

Para receber uma cadeia de caracteres que representa o HTML da página da web carregada use o método Browser.GetHTML(). Você deve usar este método apenas quando a página da web é carregada completamente. Caso contrário, você pode receber o HTML incompleto ou cadeia de caracteres vazia. O código a seguir demonstra como esperar até que a página web é carregada completamente e receber HTML da página web carregada:

C#

using System;
using DotNetBrowser;
using DotNetBrowser.Events;

namespace MyNamespace
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create Browser instance.
            Browser browser = BrowserFactory.Create();

            // Register frame loading event listener.
            browser.FinishLoadingFrameEvent += delegate(object sender, FinishLoadingEventArgs e)
            {
                // Wait until main document of the web page is loaded completely.
                if (e.IsMainFrame)
                {
                    // Get HTML of the loaded web page and write it to Console.
                    Console.Out.WriteLine(e.Browser.GetHTML());
                }
            };

            // Load teamdev.com to get its HTML content.
            browser.LoadURL("http://www.teamdev.com");
        }
    }
}

VB.NET

Imports DotNetBrowser

Module MyNamespace
    Sub Main()

        'Create Browser instance.
        Dim browser As Browser = BrowserFactory.Create()

        'Register frame loading event listener.
        AddHandler browser.FinishLoadingFrameEvent, Sub(sender, e)

            'Wait until main document of the web page is loaded completely.
            If (e.IsMainFrame) Then

                'Get HTML of the loaded web page and write it to Console.
                Console.Out.WriteLine(e.Browser.GetHTML())
            End If
        End Sub

        'Load teamdev.com to get its HTML content.
        browser.LoadURL("http://www.teamdev.com")
    End Sub
End Module

Eventos

Carregando Eventos

A interface Browser fornece a funcionalidade que permite obter eventos de carga. Você pode anexar delegados para receber notificações sobre o progresso do carregamento da página web, disponibilidade de documentos, eventos de falha de carregamento, etc. A lista de eventos de carga que você pode receber é o seguinte:

• StartLoadingFrameEvent - Um evento que indica que o processo de carregamento de frames foi iniciado.
• FinishLoadingFrameEvent - Um evento que indica que o processo de carregamento de frames foi concluído.
• ProvisionalLoadingFrameEvent - Um evento que indica que o carregamento provisório de um frame especificado foi confirmado com sucesso.
• FailLoadingFrameEvent - Um evento que indica que o processo de carregamento de frames falhou.
• DocumentLoadedInFrameEvent - Um evento que indica que um frame é carregado com um documento.
• DocumentLoadedInMainFrameEvent - Um evento que indica que o frame principal é carregado com um documento.

O código a seguir demonstra como receber e manipular vários eventos de carregamento:

C#

using System;
using DotNetBrowser;
using DotNetBrowser.Events;
namespace MyNamespace
{
    class Program
    {
        static void Main(string[] args)
        {
            ManualResetEvent waitEvent = new ManualResetEvent(false);
            // Create Browser instance.
            Browser browser = BrowserFactory.Create();
            // Register an event that will be fired when web page's frame has been completely loaded.
            browser.FinishLoadingFrameEvent += delegate(object sender, FinishLoadingEventArgs e)
            {
                Console.Out.WriteLine("FinishLoadingFrame: URL = " + e.ValidatedURL + ", IsMainFrame = " + e.IsMainFrame);
                if (e.IsMainFrame)
                {
                    waitEvent.Set();
                }
            };
            // Register an event that will be fired when web page's frame has been started loading.
            browser.StartLoadingFrameEvent += delegate(object sender, StartLoadingArgs e)
            {
                Console.Out.WriteLine("StartLoadingFrame: URL = " + e.ValidatedURL + ", IsMainFrame = " + e.IsMainFrame);
            };
            // Register an event that will be fired when document of main frame has been completely loaded.
            browser.DocumentLoadedInMainFrameEvent += delegate(object sender, LoadEventArgs e)
            {
                Console.Out.WriteLine("DocumentLoadedInMainFrame");
            };
            // Load google.com to get loading events.
            browser.LoadURL("http://www.google.com");
            //Wait until the page is loaded completely.
            waitEvent.WaitOne();
            // Dispose Browser instance.
            browser.Dispose();
        }
    }
}

VB.NET

Imports System.Threading
Imports DotNetBrowser
Imports DotNetBrowser.Events

Module MyNamespace
    Sub Main(args As String())
        Dim waitEvent As ManualResetEvent = New ManualResetEvent(False)

        'Create Browser instance.
        Dim browser As Browser = BrowserFactory.Create()
        'Register an event that will be fired when web page's frame has been completely loaded.
        AddHandler browser.FinishLoadingFrameEvent, sub(ByVal sender As Object, ByVal e As FinishLoadingEventArgs)
            Console.Out.WriteLine("FinishLoadingFrame: URL = " + e.ValidatedURL.ToString() _
                                  + ", IsMainFrame = " + e.IsMainFrame.ToString())

            If e.IsMainFrame Then
                waitEvent.Set()
            End If
        End sub
        'Register an event that will be fired when web page's frame has been started loading.
        AddHandler browser.StartLoadingFrameEvent, sub(ByVal sender As Object, ByVal e As StartLoadingArgs)
            Console.Out.WriteLine("StartLoadingFrame: URL = " + e.ValidatedURL.ToString() _
                                  + ", IsMainFrame = " + e.IsMainFrame.ToString())
        End sub
        'Register an event that will be fired when document of main frame has been completely loaded.
        AddHandler browser.DocumentLoadedInMainFrameEvent, sub(ByVal sender As Object, ByVal e As LoadEventArgs)
            Console.Out.WriteLine("DocumentLoadedInMainFrame")
        End sub
        'Load google.com to get loading events.
        browser.LoadURL("http://www.google.com")
        'Wait until the page is loaded completely.
        waitEvent.WaitOne()
        'Dispose Browser instance.
        browser.Dispose()
    End Sub
End Module

Eventos de Título

TitleChangedEvent indica que o título de um documento no frame principal foi alterado.

Para ser notificado quando o título de um documento foi alterado use o ouvinte TitleChangedEvent, como mostrado no seguinte código de exemplo:

C#

browser.TitleChangedEvent += delegate(object sender, TitleEventArgs e)
{
    string mainDocumentTitle = e.Title;
};

VB.NET

AddHandler browser.TitleChangedEvent, sub(ByVal sender As Object, ByVal e As TitleEventArgs)
    Dim mainDocumentTitle As String = e.Title
End sub

Eventos de Status

Quando o usuário move o cursor sobre um link, o motor de Chromium exibe seu URL na barra de status. O código JavaScript pode alterar o texto na barra de status de forma programática através da janela de propriedade de status também. A API DotNetBrowser fornece uma funcionalidade que lhe permite receber notificações sobre alterações de texto de barra de status.

StatusChangedEvent  indica que o texto da barra de status foi alterado.

O seguinte código de exemplo demonstra como usar essa funcionalidade:

C#

browser.StatusChangedEvent += delegate(object sender, StatusEventArgs e)
{
    string statusText = e.Text;
};

VB.NET

AddHandler browser.StatusChangedEvent, sub(ByVal sender As Object, ByVal e As StatusEventArgs)
    Dim statusText As String = e.Text
End sub

DOM

Documento

Cada página web carregada no navegador tem o seu próprio objeto de documento. Para acessar objeto de documento da página web carregada usar o método Browser.GetDocument(). Esse método retorna a instância DOMDocument que você pode usar para acessar as propriedades do documento e seus nós filhos. Por exemplo:

C#

DOMDocument document = browser.GetDocument();

VB.NET

Dim document As DOMDocument = browser.GetDocument()

Se a página da Web contém frames (veja IFRAME ou FRAME), então, cada quadro tem seu próprio objeto de documento. Para acessar objeto de documento de um frame especificado use o método Browser.GetDocument(long frameId). O frameId você pode obter do método Browser.GetFramesIds(). Por exemplo:

C#

foreach (long frameId in browser.GetFramesIds())
{
    DOMDocument frameDocument = browser.GetDocument(frameId);
}

VB.NET

For Each frameId As Long In browser.GetFramesIds()
    Dim frameDocument As DOMDocument = browser.GetDocument(frameId)
Next

Tendo a instância DOMDocument você pode trabalhar com o objeto de documento e sua estrutura DOM.

Se a página web não está completamente carregada ou ela não tem documento, então o método Browser.GetDocument() retorna null. Portanto, antes de aplicar esse método, certifique-se de que a página web é carregada completamente.

Encontrando Elementos

A API DOM DotNetBrowser fornece a funcionalidade que pode ser usada para encontrar elementos HTML na página web carregada por diferentes condições. O seguinte código de exemplo demonstra como localizar todos os elementos HTML por etiqueta de nome especificada:

C#

List<DOMNode> divs = document.GetElementsByTagName("div");

VB.NET

Dim divs As List(Of DOMNode) = document.GetElementsByTagName("div")

Se você precisa de encontrar apenas o primeiro um elemento HTML no documento faça isso da seguinte maneira:

C#

DOMElement div = document.GetElementById("myId");

VB.NET

Dim div As DOMElement = document.GetElementById("myId")

Em geral, você pode procurar por elementos HTML utilizando diferentes condições:

C#

DOMElement element = document.GetElementById("myId");
List<DOMNode> elements = document.GetElementByTagName("div");
List<DOMNode>elements = document.GetElementByClassName("myClass");
List<DOMNode> elements = document.GetElementByName("myName");
DOMNode root = document.QuerySelector("#root");

VB.NET

Dim element As DOMElement = document.GetElementById("myId")
Dim elements As List(Of DOMNode) = document.GetElementByTagName("div")
Dim elements As List(Of DOMNode) = document.GetElementByClassName("myClass")
Dim elements As List(Of DOMNode) = document.GetElementByName("myName")
Dim root As DOMNode = document.QuerySelector("#root")

Atributos de Elementos

Exemplo de código a seguir demonstra como a lista de acesso e atributos do determinado elemento DOM.

C#

using DotNetBrowser;
using DotNetBrowser.DOM;
using DotNetBrowser.Events;
using System;using System.Collections.Generic;
using System.Linq;using System.Text;
using System.Threading.Tasks;

namespace DOMGetAttributesSample
{
    class Program
    {
        static void Main(string[] args)
        {
            Browser browser = BrowserFactory.Create();
            browser.FinishLoadingFrameEvent += delegate(object sender, FinishLoadingEventArgs e)
            {
                if (e.IsMainFrame)
                {
                    DOMDocument document = e.Browser.GetDocument();
                    DOMElement link = document.GetElementById("link");
                    Dictionary<String, String> attributes = link.Attributes;
                    foreach (var attribute in attributes)
                    {
                        Console.Out.WriteLine(attribute.Key + " = " + attribute.Value);
                    }
                }
            };
            browser.LoadHTML("<html><body><a href='#' id='link' title='link title'></a></body></html>");
        }
    }
}

VB.NET

Imports DotNetBrowser
Imports DotNetBrowser.DOM
Imports DotNetBrowser.Events

Namespace DOMGetAttributesSample
    Class Program
        Private Shared Sub Main(ByVal args As String())
            Dim browser As Browser = BrowserFactory.Create()
            AddHandler browser.FinishLoadingFrameEvent, sub(ByVal sender As Object, ByVal e As FinishLoadingEventArgs)

                If e.IsMainFrame Then
                    Dim document As DOMDocument = e.Browser.GetDocument()
                    Dim link As DOMElement = document.GetElementById("link")
                    Dim attributes As Dictionary(Of String, String) = link.Attributes

                    For Each attribute In attributes
                        Console.Out.WriteLine(attribute.Key & " = " & attribute.Value)
                    Next
                End If
            End sub

            browser.LoadHTML("<html><body><a href='#' id='link' title='link title'></a></body></html>")
        End Sub
    End Class
End Namespace

Trabalhando com Campos de Formulário

O seguinte código de exemplo demonstra como preencher os campos de um formulário específico, automaticamente, quando a página é carregada completamente.

C#

using DotNetBrowser;
using DotNetBrowser.DOM;
using DotNetBrowser.Events;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DOMSetFormFieldsValuesSample
{
    class Program
    {
        static void Main(string[] args)
        {
            string loginValue = "Login";
            string passwordValue = "Password";
            using (Browser browser = BrowserFactory.Create())
            {
                ManualResetEvent waitEvent = new ManualResetEvent(false);
                browser.FinishLoadingFrameEvent += delegate(object sender, FinishLoadingEventArgs e)
                {
                    // Wait until main document of the web page is loaded completely.
                    if (e.IsMainFrame)
                    {
                        DOMDocument document = e.Browser.GetDocument();
                        List<DOMNode> forms = document.GetElementsByTagName("form");
                        foreach (DOMNode formNode in forms)
                        {
                            if (formNode.NodeType == DOMNodeType.ElementNode)
                            {
                                DOMElement form = (DOMElement)formNode;

                                if(form.GetAttribute("name").Equals("Form"))
                                {
                                    List<DOMNode> logins = form.GetElementsByName("login");

                                    foreach (DOMNode loginNode in logins)
                                    {
                                        DOMElement login = (DOMElement)loginNode;
                                        login.SetAttribute("value", loginValue);
                                        Console.Out.WriteLine("Login = " +
                                            login.GetAttribute("value"));
                                    }

                                    List<DOMNode>  passws = form.GetElementsByName("passw");
                                    foreach (DOMNode passwNode in passws)
                                    {
                                        DOMElement passw = (DOMElement)passwNode;
                                        passw.SetAttribute("value", passwordValue);
                                        Console.Out.WriteLine("Password = " +
                                            passw.GetAttribute("value"));
                                    }
                                }
                            }
                        }
                        waitEvent.Set();
                    }
                };
                browser.LoadHTML(
                    "<html>"+
                    " <body>"+
                    "   <form name='Form'>" +
                    "       Login:<br>" +
                    "       <input type='text' name='login'>" +
                    "       <br>" +
                    "       Password:<br>" +
                    "       <input type='password' name='passw'>" +
                    "       <br><br>" +
                    "       <input type='submit' value='Submit'>" +
                    "   </form>" +
                    " </body>" +
                    "</html>");

                waitEvent.WaitOne();
            }
        }
    }
}

VB.NET

Imports DotNetBrowser
Imports DotNetBrowser.DOM
Imports DotNetBrowser.Events
Imports System.Threading

Namespace DOMSetFormFieldsValuesSample
    Class Program
        Private Shared Sub Main(ByVal args As String())
            Dim loginValue As String = "Login"
            Dim passwordValue As String = "Password"

            Using browser As Browser = BrowserFactory.Create()
                Dim waitEvent As ManualResetEvent = New ManualResetEvent(False)
                AddHandler browser.FinishLoadingFrameEvent,
                    sub(ByVal sender As Object, ByVal e As FinishLoadingEventArgs)

                        If e.IsMainFrame Then
                            Dim document As DOMDocument = e.Browser.GetDocument()
                            Dim forms As List(Of DOMNode) = document.GetElementsByTagName("form")

                            For Each formNode As DOMNode In forms

                                If formNode.NodeType = DOMNodeType.ElementNode Then
                                    Dim form As DOMElement = CType(formNode, DOMElement)

                                    If form.GetAttribute("name").Equals("Form") Then
                                        Dim logins As List(Of DOMNode) = form.GetElementsByName("login")

                                        For Each loginNode As DOMNode In logins
                                            Dim login As DOMElement = CType(loginNode, DOMElement)
                                            login.SetAttribute("value", loginValue)
                                            Console.Out.WriteLine("Login = " & login.GetAttribute("value"))
                                        Next

                                        Dim passws As List(Of DOMNode) = form.GetElementsByName("passw")

                                        For Each passwNode As DOMNode In passws
                                            Dim passw As DOMElement = CType(passwNode, DOMElement)
                                            passw.SetAttribute("value", passwordValue)
                                            Console.Out.WriteLine("Password = " & passw.GetAttribute("value"))
                                        Next
                                    End If
                                End If
                            Next

                            waitEvent.[Set]()
                        End If
                    End sub

                browser.LoadHTML(
                    "<html>" & " <body>" & "   <form name='Form'>" & "       Login:<br>" &
                    "       <input type='text' name='login'>" & "       <br>" & "       Password:<br>" &
                    "       <input type='password' name='passw'>" & "       <br><br>" &
                    "       <input type='submit' value='Submit'>" & "   </form>" & " </body>" & "</html>")
                waitEvent.WaitOne()
            End Using
        End Sub
    End Class
End Namespace

Executando JavaScript

A capacidade de executar código JavaScript na página web carregada é uma das principais características da DotNetBrowser. Para executar o código JavaScript, antes de tudo você precisa ter certeza de que a página é carregada completamente.

Se a página da Web é carregada completamente, você pode executar um código JavaScript usando uma das seguintes maneiras:

Executando JavaScript sem retornar um valor

O método Browser.ExecuteJavaScript(string javaScript) executa o código JavaScript de forma assíncrona, sem bloquear a execução do encadeamento de execução atual. Se você não estiver interessado em receber o resultado do código JavaScript, você pode usar este método porque o seu parâmetro de retorno é nulo.

C#

// Executes the passed JavaScript code asynchronously.
browser.ExecuteJavaScript("document.write('<html><title>My Title</title><body>Hello from JxBrowser!</body></html>');");

VB.NET

' Executes the passed JavaScript code asynchronously
browser.ExecuteJavaScript("document.write('<html><title>My Title</title><body>Hello from JxBrowser!</body></html>');")

Executando JavaScript e retornando o resultado

O método Browser.ExecuteJavaScriptAndReturnValue(string javaScript) executa o código descrito por parâmetro javaScript e retorna o resultado da execução do código JavaScript como JSValue. Este método bloqueia a execução do encadeamento de execução atual até que o código JavaScript passado terminar a sua execução e retornar o resultado da execução.

JSValue fornece o acesso ao resultado da execução de código de JavaScript. Utilizando os métodos de JSValue você pode determinar se o valor do resultado é um objeto, número, string ou valor booleano. Por exemplo, o código a seguir demonstra como obter um valor da cadeia de caracteres do documento usando o método Browser.ExecuteJavaScriptAndReturnValue(string javaScript):

C#

JSValue documentTitle = browser.ExecuteJavaScriptAndReturnValue("document.title");
// Make sure that result value is a string and read its value
if (documentTitle.IsString())
{
    Console.WriteLine("Document Title = " + documentTitle.GetString());
}

VB.NET

Dim documentTitle As JSValue = browser.ExecuteJavaScriptAndReturnValue("document.title")
' Make sure that result value is a string and read its value
If documentTitle.IsString() Then
    Console.WriteLine("Document Title = " & documentTitle.GetString())
End If

Neste exemplo vamos verificar que o retorno JSValue é um valor de cadeia de caracteres, usando o método JSValue.IsString(); e acessar o valor da cadeia de caracteres, usando o método JSValue.GetString().

Please avoid using the Browser.ExecuteJavaScriptAndReturnValue(String javaScript) method in the UI thread,
because the passed JavaScript code can cause JavaScript Alert dialog to be shown.
All the dialogs are displayed in the UI thread by default. As result, it can cause a deadlock.

Acessando objetos JavaScript

Você pode acessar objetos JavaScript na página web carregada usando o método Browser.ExecuteJavaScriptAndReturnValue(String javaScript). Se o valor de retorno representa objeto JavaScript, então JSValue irá conter a instância que representa .NET wrapper para objeto JavaScript. A JSObject classe fornece a funcionalidade que permite trabalhar com propriedades de objetos JavaScript e chamar suas funções.

Obtenção de propriedades

Para acessar JavaScript propriedade de objeto use o método JSObject.GetProperty(String name). O código a seguir demonstra como obter o valor da propriedade document.title:

C#

JSValue document = browser.ExecuteJavaScriptAndReturnValue("document");
JSValue titleValue = document.AsObject().GetProperty("title");
String title = titleValue.GetString();

VB.NET

Dim document As JSValue = browser.ExecuteJavaScriptAndReturnValue("document")
Dim titleValue As JSValue = document.AsObject().GetProperty("title")
Dim title As String = titleValue.GetString()

Definição de propriedades

Para modificar a propriedade de objeto JavaScript com valor especificado use o método JSObject.SetProperty(String name, object value). O código a seguir demonstra como modificar a propriedade document.title com valor ‘My title’:

C#

JSValue document = browser.ExecuteJavaScriptAndReturnValue("document");
document.AsObject().SetProperty("title", "My title");

VB.NET

Dim document As JSValue = browser.ExecuteJavaScriptAndReturnValue("document")
document.AsObject().SetProperty("title", "My title")

Trabalhando com funções

A propriedade de objeto JavaScript pode representar uma função (JSFunction). Você pode usar a função de objeto JavaScript utilizando o seguinte método:

C#

JSValue document = browser.ExecuteJavaScriptAndReturnValue("document");
JSValue write = document.AsObject().GetProperty("write");
write.AsFunction().Invoke(document.AsObject(), "<html><body>Hello</body></html>");

VB.NET

Dim document As JSValue = browser.ExecuteJavaScriptAndReturnValue("document")
Dim write As JSValue = document.AsObject().GetProperty("write")
write.AsFunction().Invoke(document.AsObject(), "<html><body>Hello</body></html>")

Trabalho com matrizes

JSValue pode representar uma Matriz (JSArray). Você pode acessar os elementos da matriz usando o seguinte método:

C#

JSValue array = browser.ExecuteJavaScriptAndReturnValue("['John', 'Doe', 46];");
JSValue john = array.AsArray()[0];
JSValue doe = array.AsArray()[1];

VB.NET

Dim array As JSValue = browser.ExecuteJavaScriptAndReturnValue("['John', 'Doe', 46];")
Dim john As JSValue = array.AsArray().Item(0)
Dim doe As JSValue = array.AsArray().Item(1)

.NET para conversão de tipos JavaScript

JavaScript e .NET trabalham com diferentes tipos primitivos. A DotNetBrowser implementa conversão de tipos automática de .NET para tipos JavaScript. Veja como objetos .NET serão convertidos para seus equivalentes JavaScript pela DotNetBrowser:

Mensagens de Console

Usando o ConsoleListener você pode ouvir as mensagens de Console JavaScript com diferentes níveis: DEBUG, LOG, WARNING e ERROR. Para começar a receber Mensagens de Console, você precisa se registrar ConsoleListener para uma especificada instância Browser. Por exemplo:

С#

browser.ConsoleMessageEvent += delegate(object sender, DotNetBrowser.Events.ConsoleEventArgs e)         
{
    Console.WriteLine("Message: " + e.Message);
};

VB.NET

AddHandler browser.ConsoleMessageEvent, sub(ByVal sender As Object, ByVal e As DotNetBrowser.Events.ConsoleEventArgs)
    Console.WriteLine("Message: " & e.Message)
End sub

Exemplo

MainWindow.xaml

<Window x:Class="ConsoleListenerSample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:wpf="clr-namespace:DotNetBrowser.WPF;assembly=DotNetBrowser"
        Title="MainWindow" Height="350" Width="525"  Closing="Window_Closing">
    <Grid Name="mainLayout">
        <wpf:WPFBrowserView  Name="browserView" />
    </Grid>
</Window>

C#

MainWindow.xaml.cs

using DotNetBrowser;
using DotNetBrowser.WPF;
using System;
using System.Windows;

namespace ConsoleListenerSample
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            browserView.Browser.LoadURL("http://www.google.com");
            browserView.Browser.ConsoleMessageEvent += Browser_ConsoleMessageEvent;
            browserView.Browser.ExecuteJavaScript("console.error(\"Error message\");");
        }

        private void Browser_ConsoleMessageEvent(object sender, DotNetBrowser.Events.ConsoleEventArgs e)
        {
            Console.WriteLine("Message: " + e.Message);
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            // Dispose BrowserView when close app window.
            browserView.Dispose();
            browserView.Browser.Dispose();
        }
    }
}

VB.NET

MainWindow.xaml.vb

Namespace ConsoleListenerSample
    
    ''' <summary>
    ''' Interaction logic for MainWindow.xaml
    ''' </summary>
    Public Partial Class MainWindow
        Inherits Window

        Public Sub New()
            InitializeComponent()
            browserView.Browser.LoadURL("http://www.google.com")
            AddHandler browserView.Browser.ConsoleMessageEvent, AddressOf Browser_ConsoleMessageEvent
            browserView.Browser.ExecuteJavaScript("console.error(""Error message"");")
        End Sub

        Private Sub Browser_ConsoleMessageEvent(ByVal sender As Object, ByVal e As DotNetBrowser.Events.ConsoleEventArgs)
            Console.WriteLine("Message: " & e.Message)
        End Sub

        Private Sub Window_Closing(ByVal sender As Object, ByVal e As System.ComponentModel.CancelEventArgs)
            ' Dispose BrowserView when close app window.
            browserView.Dispose()
            browserView.Browser.Dispose()
        End Sub
    End Class
End Namespace

JavaScript-.NET Bridge

Chamando o .NET de JavaScript

A API JavaScript-.NET Bridge permite injetar objetos .NET em código JavaScript. Este é um poderoso recurso que permite acessar a funcionalidade .NET a partir de JavaScript.

Nota: Para acessar os objetos de JavaScript e injetar os objetos de .NET, certifique-se de que a página web é carregada completamente
e o suporte de JavaScript está habilitado. Se você injetar ou registrar objeto .NET e, em seguida, carregue a página da web.
Todos os objetos .NET registrados serão destruídos e não estarão disponíveis em JavaScript da página web carregada.

Injetando objetos .NET

Para injetar objeto .NET para JavaScript você precisa associar o objeto .NET com propriedade especificada de um objeto JavaScript. Por exemplo, você pode adicionar uma nova propriedade ao objeto JavaScript global de window (outros objetos irão funcionar também) e associar esta propriedade com o objeto .NET usando o seguinte código:

C#

JSValue window = browser.ExecuteJavaScriptAndReturnValue("window");
window.AsObject().SetProperty("csharp", new CSharpObject());

VB.NET

Dim window As JSValue = browser.ExecuteJavaScriptAndReturnValue("window")
window.AsObject().SetProperty("csharp", New CSharpObject())

Nota: Para injetar objeto .NET em código JavaScript, recomendamos que você use o seguinte método:

C#

browser.FinishLoadingFrameEvent += delegate(object sender, FinishLoadingEventArgs e)
{
    if (e.IsMainFrame)
    {
        JSValue value = browser.ExecuteJavaScriptAndReturnValue("window");
        value.AsObject().SetProperty("Account", new Account());
    }
};

VB.NET

AddHandler browser.FinishLoadingFrameEvent, sub(ByVal sender As Object, ByVal e As FinishLoadingEventArgs)
    If e.IsMainFrame Then
        Dim value As JSValue = browser.ExecuteJavaScriptAndReturnValue("window")
        value.AsObject().SetProperty("Account", New Account())
    End If
End sub

A implementação do objeto .NET pode ser o seguinte:

C#

public class Account
{
    public void Save(String firstName, String lastName)
    {
        Console.Out.WriteLine("firstName = " + firstName);
        Console.Out.WriteLine("lastName = " + lastName);
    }
}

VB.NET

Public Class Account
    Public Sub Save(ByVal firstName As String, ByVal lastName As String)
        Console.Out.WriteLine("firstName = " & firstName)
        Console.Out.WriteLine("lastName = " & lastName)
    End Sub
End Class

Nota: Certifique-se de que você injeta o objeto .NET qual classe/interface está marcado como público.
Somente as classes públicas podem ser registradas e acessadas a partir de JavaScript.

Agora o código de JavaScript pode chamar métodos de objeto público:

JavaScript

window.Account.Save("FirstName", "LastName");

Nota: O código JavaScript pode acessar/chamar apenas métodos públicos de objetos registrados .NET.

Como JavaScript chama método .NET

Quando JavaScript chama um método público de um objeto .NET registrado, os parâmetros de JavaScript são convertidos automaticamente para objetos .NET/valores primitivos por DotNetBrowser.

Se a DotNetBrowser não puder converter valores de JavaScript passados ou encontrar um método com a assinatura apropriada, será exibido um erro de JavaScript.

Se objeto .NET registrado tem vários métodos com o mesmo nome e número de parâmetros, mas os tipos de parâmetros diferentes, o JavaScript irá chamar o primeiro método declarado na classe .NET.

JavaScript para conversão de tipos .NET

JavaScript e .NET trabalham com diferentes tipos primitivos. DotNetBrowser implementa a conversão automática de tipos JavaScript para tipos .NET. Veja como objetos JavaScript serão convertidos para seus equivalentes .NET por DotNetBrowser:

Salvando imagem de página da Web

Para tirar uma screenshot de uma página da web especificada você precisará seguir os passos abaixo:

1. Criar instância Browser.
2. Definir o tamanho da Browser necessário.
3. Criar uma BrowserView (WPF ou WinForms) com esta instância Browser
4. Carregar página web necessária por sua URL ou HTML e esperar até que seu conteúdo será renderizado completamente.
5. Obter Drawing.Image de Sistema da página web carregada usando BrowserView.GetImage().

Note: the OnRepaint event used in the following sample is supported for lightweight rendering mode only.
The GetImage() method works for both modes, but the component should be embedded and shown before calling this method.

Exemplo

O exemplo a seguir demonstra como capturar a imagem da página web completa. Neste caso, você ainda não precisa incorporar visualização do navegador.

C#

using DotNetBrowser;
using DotNetBrowser.Events;
using DotNetBrowser.WPF;
using System;
using System.Drawing.Imaging;
using System.Threading;
using System.Windows;

namespace HTMLToImageSample
{
    public partial class WindowMain : Window
    {
        private WPFBrowserView browserView;

        public WindowMain()
        {
            this.Loaded += delegate
            {
                Width = 400;
                Height = 300;
                browserView = new WPFBrowserView(BrowserFactory.Create(BrowserType.LIGHTWEIGHT));
                Browser browser = browserView.Browser;

                // #1 Set browser initial size
                browserView.Browser.SetSize(1280, 1024);

                // #2 Load web page and wait until web page is loaded completely.
                ManualResetEvent resetEvent = new ManualResetEvent(false);
                FinishLoadingFrameHandler listener = new FinishLoadingFrameHandler(
                    (object sender, FinishLoadingEventArgs e) =>
                    {
                        if (e.IsMainFrame)
                        {
                            resetEvent.Set();
                        }
                    });
                browser.FinishLoadingFrameEvent += listener;

                try
                {
                    browser.LoadURL("teamdev.com/dotnetbrowser");
                    resetEvent.WaitOne(new TimeSpan(0, 0, 45));
                }
                finally
                {
                    browser.FinishLoadingFrameEvent -= listener;
                }

                // #3 Set the required document size.
                JSValue documentHeight = browserView.Browser.ExecuteJavaScriptAndReturnValue(
                    "Math.max(document.body.scrollHeight, " +
                    "document.documentElement.scrollHeight, document.body.offsetHeight, " +
                    "document.documentElement.offsetHeight, document.body.clientHeight, " +
                    "document.documentElement.clientHeight);");

                JSValue documentWidth = browserView.Browser.ExecuteJavaScriptAndReturnValue(
                    "Math.max(document.body.scrollWidth, " +
                    "document.documentElement.scrollWidth, document.body.offsetWidth, " +
                    "document.documentElement.offsetWidth, document.body.clientWidth, " +
                    "document.documentElement.clientWidth);");

                int scrollBarSize = 25;
                int viewWidth = (int) documentWidth.GetNumber() + scrollBarSize;
                int viewHeight = (int) documentHeight.GetNumber() + scrollBarSize;

                // #4 Register OnRepaint to get notifications
                // about paint events. We expect that web page will be completely rendered twice:
                // 1. When its size is updated.
                // 2. When HTML content is loaded and displayed.

                ManualResetEvent waitEvent = new ManualResetEvent(false);
                DrawingView drawingView = (DrawingView) browserView.GetInnerView();
                drawingView.OnRepaint += delegate(object sender, OnRepaintEventArgs e)
                {
                    // Make sure that all view content has been repainted.
                    if (e.UpdatedRect.Size.Equals(e.ClientSize))
                    {
                        waitEvent.Set();
                    }
                };

                browserView.Browser.SetSize(viewWidth, viewHeight);
                // #5 Wait until Chromium renders web page content.
                waitEvent.WaitOne();

                // #6 Save Image of the loaded web page into a PNG file.
                Dispatcher.BeginInvoke((Action) (() => { browserView.GetImage().Save(@"teamdev.png", ImageFormat.Png); }
                    ));
            };
        }

        [STAThread]
        public static void Main()
        {
            Application app = new Application();
            WindowMain wnd = new WindowMain();
            app.Run(wnd);
            var browser = wnd.browserView.Browser;
            wnd.browserView.Dispose();
            browser.Dispose();
        }
    }
}

VB.NET

Imports DotNetBrowser
Imports DotNetBrowser.Events
Imports DotNetBrowser.WPF
Imports System.Drawing.Imaging
Imports System.Threading
Imports System.Windows

Module HTMLToImageSample
    Public Partial Class WindowMain
        Inherits Window

        Private browserView As WPFBrowserView

        Public Sub New()
            AddHandler Me.Loaded, sub()
                Width = 400
                Height = 300
                browserView = New WPFBrowserView(BrowserFactory.Create(BrowserType.LIGHTWEIGHT))
                Dim browser As Browser = browserView.Browser
                browserView.Browser.SetSize(1280, 1024)
                Dim resetEvent As ManualResetEvent = New ManualResetEvent(False)
                Dim listener As FinishLoadingFrameHandler =
                        New FinishLoadingFrameHandler(sub(ByVal sender As Object, ByVal e As FinishLoadingEventArgs)

                            If e.IsMainFrame Then
                                resetEvent.Set()
                            End If
                        End sub)
                AddHandler browser.FinishLoadingFrameEvent, listener

                Try
                    browser.LoadURL("teamdev.com/dotnetbrowser")
                    resetEvent.WaitOne(New TimeSpan(0, 0, 45))
                Finally
                    RemoveHandler browser.FinishLoadingFrameEvent, listener
                End Try

                Dim documentHeight As JSValue =
                        browserView.Browser.ExecuteJavaScriptAndReturnValue(
                            "Math.max(document.body.scrollHeight, " &
                            "document.documentElement.scrollHeight, document.body.offsetHeight, " &
                            "document.documentElement.offsetHeight, document.body.clientHeight, " &
                            "document.documentElement.clientHeight);")
                Dim documentWidth As JSValue =
                        browserView.Browser.ExecuteJavaScriptAndReturnValue(
                            "Math.max(document.body.scrollWidth, " &
                            "document.documentElement.scrollWidth, document.body.offsetWidth, " &
                            "document.documentElement.offsetWidth, document.body.clientWidth, " &
                            "document.documentElement.clientWidth);")
                Dim scrollBarSize As Integer = 25
                Dim viewWidth As Integer = CInt(documentWidth.GetNumber()) + scrollBarSize
                Dim viewHeight As Integer = CInt(documentHeight.GetNumber()) + scrollBarSize
                Dim waitEvent As ManualResetEvent = New ManualResetEvent(False)
                Dim drawingView As DrawingView = CType(browserView.GetInnerView(), DrawingView)
                AddHandler drawingView.OnRepaint, sub(ByVal sender As Object, ByVal e As OnRepaintEventArgs)

                    If e.UpdatedRect.Size.Equals(e.ClientSize) Then
                        waitEvent.Set()
                    End If
                End sub

                browserView.Browser.SetSize(viewWidth, viewHeight)
                waitEvent.WaitOne()
                Dispatcher.BeginInvoke(CType((sub()
                    browserView.GetImage().Save("teamdev.png", ImageFormat.Png)
                End sub),
                                             Action))
            End sub
        End Sub

        <STAThread>
        Public Shared Sub Main()
            Dim app As Application = New Application()
            Dim wnd As WindowMain = New WindowMain()
            app.Run(wnd)
            Dim browser = wnd.browserView.Browser
            wnd.browserView.Dispose()
            browser.Dispose()
        End Sub
    End Class
End Module

Calculando Tamanho da Página

Se você precisa tirar screenshot da página da web inteira, incluindo roláveis partes ocultas e não sabe a dimensão da página da web, então você precisa calculá-lo usando o seguinte método:

C#

JSValue documentHeight = browserView.Browser.ExecuteJavaScriptAndReturnValue(
    "Math.max(document.body.scrollHeight, " +
    "document.documentElement.scrollHeight, document.body.offsetHeight, " +
    "document.documentElement.offsetHeight, document.body.clientHeight, " +
    "document.documentElement.clientHeight);");

JSValue documentWidth = browserView.Browser.ExecuteJavaScriptAndReturnValue(
    "Math.max(document.body.scrollWidth, " +
    "document.documentElement.scrollWidth, document.body.offsetWidth, " +
    "document.documentElement.offsetWidth, document.body.clientWidth, " +
    "document.documentElement.clientWidth);");

int scrollBarSize = 25;
int viewWidth = (int) documentWidth.GetNumber() + scrollBarSize;
int viewHeight = (int) documentHeight.GetNumber() + scrollBarSize;

VB.NET

Dim documentHeight As JSValue = browserView.Browser.ExecuteJavaScriptAndReturnValue(
            "Math.max(document.body.scrollHeight, " &
            "document.documentElement.scrollHeight, document.body.offsetHeight, " &
            "document.documentElement.offsetHeight, document.body.clientHeight, " &
            "document.documentElement.clientHeight);")
Dim documentWidth As JSValue = browserView.Browser.ExecuteJavaScriptAndReturnValue(
            "Math.max(document.body.scrollWidth, " &
            "document.documentElement.scrollWidth, document.body.offsetWidth, " &
            "document.documentElement.offsetWidth, document.body.clientWidth, " &
            "document.documentElement.clientWidth);")

Dim scrollBarSize As Integer = 25
Dim viewWidth As Integer = CInt(documentWidth.GetNumber()) + scrollBarSize
Dim viewHeight As Integer = CInt(documentHeight.GetNumber()) + scrollBarSize

Neste código usamos o JavaScript e DOM API` para obter a dimensão do documento carregado.

Popups

Qualquer página da web pode exibir janelas pop-up usando o recurso de JavaScript window.open(). Por exemplo:

JavaScript

window.open("http://www.google.com", "_blank", "toolbar=yes, scrollbars=yes, resizable=yes, top=500, left=500, width=400, height=400");

A API da DotNetBrowser fornece a classe PopupHandler para personalizar a manipulação na criação de janelas pop-up. Para personalizar as janelas de popup você precisa registrar sua própria implementação de PopupHandler dependendo do GUI Toolkit que você usa em seu aplicativo .NET. Veja:

• Manipulação de Popups WPF
• Manipulação de Popups WinForms

Desabilitar Popups

Por padrão, janelas pop-up estão habilitadas. Para desativar janelas pop-up, você deve criar sua própria implementação de PopupHandler e retornar nulo do HandlePopup() método, como mostrado abaixo:

C#

public class SamplePopupHandler : PopupHandler
{
    public PopupContainer HandlePopup(PopupParams popupParams)
    {
        return null;
    }
}

VB.NET

Public Class SamplePopupHandler
    Implements PopupHandler

    Public Function HandlePopup(ByVal popupParams As PopupParams) As PopupContainer _
        Implements PopupHandler.HandlePopup
        Return Nothing
    End Function
End Class

Uso:

C#

 browser.PopupHandler = new SamplePopupHandler();

VB.NET

 browser.PopupHandler = New SamplePopupHandler()

Eliminação de Popup

Há duas maneiras de eliminar a janela pop-up:manualmente usando o método Browser.Dispose() e por meio de programação de JavaScript usando o recurso window.close(). Se você usar sua própria implementação de PopupHandler, você precisa lidar com situação quando a janela pop-up está disposto a partir de JavaScript. Usando DisposeEvent você pode ouvir evento quando a pop-up da instância Browser está disposto a destruir recipiente de pop-up. Caso contrário, você pode ter o problema quando instância Browser é descartado, mas seu recipiente é aberto e exibe o conteúdo de cinza.

O código a seguir demonstra como manipular tal situação em sua implementação de PopupHandler:

WinForms:

C#

browser.DisposeEvent += delegate (object sender, DisposeEventArgs e)
{
    form.BeginInvoke((Action)(() =>
    {
        if(!formClosed)
        {
            form.Controls.Clear();
            form.Hide();
            form.Close();
            formClosed = true;
        }
    }));
};

VB.NET

AddHandler browser.DisposeEvent, Sub(sender, e)
   form.BeginInvoke(Sub()
       If (Not (formClosed)) Then
           form.Controls.Clear()
           form.Hide()
           form.Close()
           formClosed = True
       End If
   End Sub)
End Sub

WPF:

C#

browser.DisposeEvent += delegate(object sender, DisposeEventArgs e)
{
    Application.Current.Dispatcher.Invoke((Action)(() =>
    {
        window.Content = null;
        window.Hide();
        window.Close();
    }));
};

VB.NET

AddHandler browser.DisposeEvent, 
     Sub(sender, e)
        Application.Current.Dispatcher.Invoke(
            Sub()
              window.Content = Nothing
              window.Hide()
              window.Close()
            End Sub)
     End Sub

Caixas de diálogo

OnBeforeUnload

O evento onbeforeunload é acionado quando o documento está prestes a ser descarregado. Esse evento permite que você exibir uma mensagem em uma caixa de diálogo de confirmação para informar o usuário se quer ficar ou sair da página atual. A API DotNetBrowser permite a manipulação desta caixa de diálogo usando a API DialogHandler. Por padrão, a caixa de diálogo é exibida. Usando sua implementação personalizada de DialogHandler, você pode lidar com esta caixa de diálogo do seu jeito. Por exemplo, você pode exibir sua mensagem personalizada de diálogo ou suprimir a caixa de diálogo e não permitir a descarga de página da web.

O exemplo a seguir demonstra como manipular a caixa de diálogo onbeforeunload:

MainWindow.xaml

<Window x:Class="WPFDialogHandlerSample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:wpf="clr-namespace:DotNetBrowser.WPF;assembly=DotNetBrowser"
        Title="MainWindow" Height="350" Width="525">
    <Grid Name="mainLayout">
        <wpf:WPFBrowserView Name="browserView"/>
    </Grid>
</Window>

C#

MainWindow.xaml.cs

using System;
using System.Windows;
using System.Windows.Controls;
using DotNetBrowser;
using DotNetBrowser.WPF;

namespace WPFDialogHandlerSample
{

    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            // Initialize WPF Application UI.
            InitializeComponent();

            var defaultHandler = browserView.Browser.DialogHandler;
            browserView.Browser.DialogHandler = new CustomDialogHandler(defaultHandler);

            // Load HTML from string into BrowserView.
            browserView.Browser.LoadHTML("<html><body onbeforeunload='return myFunction()'>" +
                "<a href='http://www.google.com'>Click here to leave</a>" +
                "<script>function myFunction() { return 'Leave this web page?'; }" +
                "</script></body></html>");
        }
    }

    public class CustomDialogHandler : DialogHandler
    {
        private DialogHandler defaultHandler;

        public CustomDialogHandler(DialogHandler defaultHandler)
        {
            this.defaultHandler = defaultHandler;
        }

        public CloseStatus OnBeforeUnload(UnloadDialogParams parameters) {
            CloseStatus returnValue = CloseStatus.CANCEL;
            String title = "Confirm Navigation";
            String message = parameters.Message;
            MessageBoxResult result = MessageBox.Show(message, title, MessageBoxButton.YesNo, MessageBoxImage.Question);
            if (result == MessageBoxResult.Yes)
            {
                returnValue = CloseStatus.OK;
            }
            return returnValue;
        }

        public void OnAlert(DialogParams parameters)
        {
            defaultHandler.OnAlert(parameters);
        }

        public CloseStatus OnConfirmation(DialogParams parameters)
        {
            return defaultHandler.OnConfirmation(parameters);
        }

        public CloseStatus OnFileChooser(FileChooserParams parameters)
        {
            return defaultHandler.OnFileChooser(parameters);
        }

        public CloseStatus OnPrompt(PromptDialogParams parameters)
        {
            return defaultHandler.OnPrompt(parameters);
        }

        public CloseStatus OnReloadPostData(ReloadPostDataParams parameters)
        {
            return defaultHandler.OnReloadPostData(parameters);
        }

        public CloseStatus OnColorChooser(ColorChooserParams parameters)
        {
            return defaultHandler.OnColorChooser(parameters);
        }

        public CloseStatus OnSelectCertificate(CertificatesDialogParams parameters)
        {
            return defaultHandler.OnSelectCertificate(parameters);
        }
    }
}

VB.NET

MainWindow.xaml.vb

Imports DotNetBrowser

Namespace WPFDialogHandlerSample
    Class MainWindow
        Inherits Window

        Sub New()
            ' Initialize WPF Application UI.
            InitializeComponent()

            Dim defaultHandler = browserView.Browser.DialogHandler
            browserView.Browser.DialogHandler = new CustomDialogHandler(defaultHandler)

            ' Load HTML from string into BrowserView.
            browserView.Browser.LoadHTML("<html><body onbeforeunload='return myFunction()'>" +
                                         "<a href='http://www.google.com'>Click here to leave</a>" +
                                         "<script>function myFunction() { return 'Leave this web page?'; }" +
                                         "</script></body></html>")
        End Sub
    End Class

    Friend Class CustomDialogHandler
        Implements DialogHandler

        Private defaultHandler As DialogHandler

        Public Sub New(defaultHandler As DialogHandler)
            Me.defaultHandler = defaultHandler
        End Sub

        Public Function OnBeforeUnload(parameters As UnloadDialogParams) As CloseStatus _
            Implements DialogHandler.OnBeforeUnload
            Dim returnValue As CloseStatus = CloseStatus.CANCEL
            Dim title As String = "Confirm Navigation"
            Dim message As String = parameters.Message
            Dim result As MessageBoxResult = MessageBox.Show(message, title, MessageBoxButton.YesNo,
                                                             MessageBoxImage.Question)
            If result = MessageBoxResult.Yes Then

                returnValue = CloseStatus.OK
            End If
            return returnValue
        End Function

        Public Sub OnAlert(parameters As DialogParams) Implements DialogHandler.OnAlert
            defaultHandler.OnAlert(parameters)
        End Sub

        Public Function OnColorChooser(parameters As ColorChooserParams) As CloseStatus _
            Implements DialogHandler.OnColorChooser
            return defaultHandler.OnColorChooser(parameters)
        End Function

        Public Function OnConfirmation(parameters As DialogParams) As CloseStatus _
            Implements DialogHandler.OnConfirmation
            return defaultHandler.OnConfirmation(parameters)
        End Function

        Public Function OnFileChooser(parameters As FileChooserParams) As CloseStatus _
            Implements DialogHandler.OnFileChooser
            return defaultHandler.OnFileChooser(parameters)
        End Function

        Public Function OnPrompt(parameters As PromptDialogParams) As CloseStatus Implements DialogHandler.OnPrompt
            return defaultHandler.OnPrompt(parameters)
        End Function

        Public Function OnReloadPostData(parameters As ReloadPostDataParams) As CloseStatus _
            Implements DialogHandler.OnReloadPostData
            return defaultHandler.OnReloadPostData(parameters)
        End Function

        Public Function OnSelectCertificate(parameters As CertificatesDialogParams) As CloseStatus _
            Implements DialogHandler.OnSelectCertificate
            return defaultHandler.OnSelectCertificate(parameters)
        End Function
    End Class
End Namespace

Selecionar Certificado SSL

Usando a API DotNetBrowser DialogHandler você pode lidar com situação quando na caixa de diálogo Selecionar Certificado SSL será exibido. Por padrão a DotNetBrowser exibe sua própria implementação da caixa de diálogo onde o usuário pode selecionar certificado exigido na lista de certificados disponíveis. A fim de substituir o comportamento padrão, você deve registrar a sua própria implementação da interfce DialogHandler com substituído método DialogHandler.OnSelectCertificate(CertificatesDialogParams parameters). Sua implementação pode exibir sua própria caixa de diálogo ou suprimir a caixa de diálogo e selecionar certificado exigido por meio de programação.

O exemplo a seguir demonstra como substituir a implementação padrão com lógica personalizada Selecionar Certificado SSL:

C#

using System;
using System.Collections.Generic;
using DotNetBrowser;

namespace CertificateSelectSample
{
    /// <summary>
    /// Demonstrates how to handle SSL certificate selection.
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Browser browser = BrowserFactory.Create();
            browser.DialogHandler = new SampleDialogHandler((selectCertificateParameters) =>
            {
                String message = "Select a certificate to authenticate yourself to " +
                                 selectCertificateParameters.HostPortPair.HostPort;
                Console.WriteLine(message);

                List<Certificate> certificates = selectCertificateParameters.Certificates;
                if (!(certificates.Count == 0))
                {
                    Object selectedValue = certificates[0];
                    if (selectedValue != null)
                    {
                        selectCertificateParameters.SelectedCertificate = ((Certificate) selectedValue);
                        return CloseStatus.OK;
                    }
                }

                return CloseStatus.CANCEL;
            });
            browser.LoadURL("<URL that causes Select SSL Certificate dialog>");
        }

        private class SampleDialogHandler : DialogHandler
        {
            private Func<CertificatesDialogParams, CloseStatus> certificateAction;

            public SampleDialogHandler(Func<CertificatesDialogParams, CloseStatus> certificateAction)
            {
                this.certificateAction = certificateAction;
            }

            public void OnAlert(DialogParams parameters)
            {
            }

            public CloseStatus OnConfirmation(DialogParams parameters)
            {
                return CloseStatus.CANCEL;
            }

            public CloseStatus OnPrompt(PromptDialogParams parameters)
            {
                return CloseStatus.CANCEL;
            }

            public CloseStatus OnFileChooser(FileChooserParams parameters)
            {
                return CloseStatus.CANCEL;
            }

            public CloseStatus OnBeforeUnload(UnloadDialogParams parameters)
            {
                return CloseStatus.CANCEL;
            }

            public CloseStatus OnSelectCertificate(CertificatesDialogParams parameters)
            {
                return certificateAction(parameters);
            }

            public CloseStatus OnReloadPostData(ReloadPostDataParams parameters)
            {
                return CloseStatus.CANCEL;
            }

            public CloseStatus OnColorChooser(ColorChooserParams parameters)
            {
                return CloseStatus.CANCEL;
            }
        }
    }
}

VB.NET

Imports DotNetBrowser

''' <summary>
'''Demonstrates how to handle SSL certificate selection.
''' </summary>
Module CertificateSelectSample
    Sub Main()
        Dim browser As Browser = BrowserFactory.Create()
        browser.DialogHandler = new SampleDialogHandler()
        browser.LoadURL("<URL that causes Select SSL Certificate dialog>")
    End Sub

    Friend Class SampleDialogHandler
        Implements DialogHandler

        Public Sub OnAlert(parameters As DialogParams) Implements DialogHandler.OnAlert
        End Sub

        Public Function OnConfirmation(parameters As DialogParams) As CloseStatus _
            Implements DialogHandler.OnConfirmation
            Return CloseStatus.CANCEL
        End Function

        Public Function OnPrompt(parameters As PromptDialogParams) As CloseStatus Implements DialogHandler.OnPrompt
            Return CloseStatus.CANCEL
        End Function

        Public Function OnFileChooser(parameters As FileChooserParams) As CloseStatus _
            Implements DialogHandler.OnFileChooser
            Return CloseStatus.CANCEL
        End Function

        Public Function OnBeforeUnload(parameters As UnloadDialogParams) As CloseStatus _
            Implements DialogHandler.OnBeforeUnload
            Return CloseStatus.CANCEL
        End Function

        Public Function OnSelectCertificate(parameters As CertificatesDialogParams) As CloseStatus _
            Implements DialogHandler.OnSelectCertificate
            Dim message As String = "Select a certificate to authenticate yourself to " +
                                    parameters.HostPortPair.HostPort
            Console.WriteLine(message)
            Dim certificates As List(Of Certificate) = parameters.Certificates
            If Not (certificates.Count = 0) Then
                Dim selectedValue As Object = certificates.Item(0)
                If selectedValue IsNot Nothing Then
                    parameters.SelectedCertificate = CType(selectedValue, Certificate)
                    Return CloseStatus.OK
                End If
            End If
            Return CloseStatus.CANCEL
        End Function

        Public Function OnReloadPostData(parameters As ReloadPostDataParams) As CloseStatus _
            Implements DialogHandler.OnReloadPostData
            Return CloseStatus.CANCEL
        End Function

        Public Function OnColorChooser(parameters As ColorChooserParams) As CloseStatus _
            Implements DialogHandler.OnColorChooser
            Return CloseStatus.CANCEL
        End Function
    End Class
End Module

Manipulação de Erros de Certificado SSL

Por padrão, que a DotNetBrowser rejeita a carregar os sites HTTPS com certificados SSL inválidos, por razões de segurança. Se você precisa ignorar certificados SSL inválidos e continuar a carregar a página da web, você pode registrar sua implementação LoadHandler onde você decide se certificados SSL inválidos devem ser ignorados ou não. 

Por exemplo:

C#

private class SampleLoadHandler : DefaultLoadHandler
{
    public override bool OnCertificateError(CertificateErrorParams errorParams)
    {
        // Return false to ignore certificate error.
        return false;
    }
}

VB.NET

Private Class SampleLoadHandler
    Inherits DefaultLoadHandler

    Public Overrides Function OnCertificateError(ByVal errorParams As CertificateErrorParams) As Boolean
        'Return false to ignore certificate error.
        Return False
    End Function
End Class

O parâmetro CertificateErrorParams fornece informações sobre o certificado SSL inválido. Você pode decidir se o certificado é permitido ou não usando seus detalhes.

C#

using DotNetBrowser;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace CertificateErrorSample
{
    /// <summary>
    /// Demonstrates how to handle SSL certificate errors.
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Browser browser = BrowserFactory.Create();

            browser.LoadHandler = new SampleLoadHandler();

            browser.LoadURL("<https-url-with-invalid-ssl-certificate>");

        }

        private class SampleLoadHandler : DefaultLoadHandler
        {
            public override bool OnCertificateError(CertificateErrorParams errorParams)
            {
                Certificate certificate = errorParams.Certificate;

                Console.WriteLine("ErrorCode = " + errorParams.CertificateError);
                Console.WriteLine("SerialNumber = " + certificate.SerialNumber);
                Console.WriteLine("FingerPrint = " + certificate.FingerPrint);
                Console.WriteLine("CAFingerPrint = " + certificate.CAFingerPrint);

                string subject = certificate.Subject;
                Console.WriteLine("Subject = " + subject);

                string issuer = certificate.Issuer;
                Console.WriteLine("Issuer = " + issuer);

                Console.WriteLine("KeyUsages = " + String.Join(", ", certificate.KeyUsages));
                Console.WriteLine("ExtendedKeyUsages = " + String.Join(", ", certificate.ExtendedKeyUsages));

                Console.WriteLine("HasExpired = " + certificate.HasExpired);

                // Return false to ignore certificate error.
                return false;
            }
        }
    }
}

VB.NET

Imports DotNetBrowser

Module CertificateErrorSample
    Sub Main()
        Dim browser As Browser = BrowserFactory.Create()
        browser.LoadHandler = New SampleLoadHandler()
        browser.LoadURL("<https-url-with-invalid-ssl-certificate>")
    End Sub

    Private Class SampleLoadHandler
        Inherits DefaultLoadHandler

        Public Overrides Function OnCertificateError(ByVal errorParams As CertificateErrorParams) As Boolean
            Dim certificate As Certificate = errorParams.Certificate
            Console.WriteLine("ErrorCode = " & errorParams.CertificateError)
            Console.WriteLine("SerialNumber = " & certificate.SerialNumber)
            Console.WriteLine("FingerPrint = " & certificate.FingerPrint)
            Console.WriteLine("CAFingerPrint = " & certificate.CAFingerPrint)
            Dim subject As String = certificate.Subject
            Console.WriteLine("Subject = " & subject)
            Dim issuer As String = certificate.Issuer
            Console.WriteLine("Issuer = " & issuer)
            Console.WriteLine("KeyUsages = " & String.Join(", ", certificate.KeyUsages))
            Console.WriteLine("ExtendedKeyUsages = " & String.Join(", ", certificate.ExtendedKeyUsages))
            Console.WriteLine("HasExpired = " & certificate.HasExpired)

            'Return false to ignore certificate error.
            Return False
        End Function
    End Class
End Module

Carregamentos de Arquivo

A DotNetBrowser fornece a API que permite tratar todos os carregamentos de arquivo. Usando esta API pode controlar de que arquivos devem ser carregados, forneça o caminho para o diretório de destino onde o arquivo deve salvar-se e acompanha o progresso de download.

Você pode registrar sua própria implementação da interface DownloadHandler para lidar com carregamentos de arquivo do seu próprio modo. O exemplo a seguir demonstra como fazer isso:

C#

using DotNetBrowser;
using DotNetBrowser.Events;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DownloadSample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (Browser browser = BrowserFactory.Create())
            {

                var downloadHandler = new SampleDownloadHandler();
                browser.DownloadHandler = downloadHandler;

                browser.LoadURL("ftp://ftp.teamdev.com/updates/jxbrowser-4.0-beta.zip");
                downloadHandler.Wait();
            }
        }

        class SampleDownloadHandler : DownloadHandler
        {
            private ManualResetEvent waitEvent = new ManualResetEvent(false);

            public bool AllowDownload(DownloadItem download)
            {
                download.DownloadEvent += delegate(object sender, DownloadEventArgs e)
                {
                    DownloadItem downloadItem = e.Item;
                    if (downloadItem.Completed)
                    {
                        Console.Out.WriteLine("Download is completed!");
                        waitEvent.Set();
                    }
                };
                Console.Out.WriteLine("Destination file: " +
                        download.DestinationFile);                
                return true;
            }

            public void Wait()
            {
                waitEvent.WaitOne();
            }
        }
    }
}

VB.NET

Imports System.Threading
Imports DotNetBrowser
Imports DotNetBrowser.Events

Module DownloadSample
    Sub Main()
        Using browser As Browser = BrowserFactory.Create()
            Dim downloadHandler = new SampleDownloadHandler()
            browser.DownloadHandler = downloadHandler

            browser.LoadURL("ftp://ftp.teamdev.com/updates/jxbrowser-4.0-beta.zip")
            downloadHandler.Wait()
        End Using
    End Sub

    Friend Class SampleDownloadHandler
        Implements DownloadHandler

        Private Dim waitEvent As ManualResetEvent = new ManualResetEvent(False)

        Public Function AllowDownload(download As DownloadItem) As Boolean Implements DownloadHandler.AllowDownload
            AddHandler download.DownloadEvent, sub(sender As Object, e As DownloadEventArgs)
                Dim downloadItem As DownloadItem = e.Item
                
                If downloadItem.Completed Then
                    Console.Out.WriteLine("Download is completed!")
                    waitEvent.Set()
                End If
            End sub

            Console.Out.WriteLine("Destination file: " +
                                  download.DestinationFile)
            Return True
        End Function

        Public Sub Wait()
            waitEvent.WaitOne()
        End Sub
    End Class
End Module

A classe DownloadItem fornece os métodos para pausar e cancelar processo de carregamento. Consulte seus métodos correspondentes.

Upload de Arquivo

Usando a API DotNetBrowser DialogHandler Você pode lidar com a situação quando a página da web precisa exibir a caixa de diálogo de File Open (e.g. quando o usuário clica File Input em um formulário web). Usando esta API você pode exibir sua própria caixa de diálogo File Open ou suprimir a caixa de diálogo, e forneça o caminho para um arquivo de programa.

Nota: Por padrão, a DotNetBrowser exibe caixa de diálogo padrão de OpenFileChooser.

O exemplo a seguir demonstra como modificar esta lógica:

C#

using DotNetBrowser;
using DotNetBrowser.Events;
using DotNetBrowser.WPF;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;

namespace FileUploadSample
{
    class Program
    {
        public class WindowMain : Window
        {
            private WPFBrowserView browserView;

            public WindowMain()
            {
                Browser browser = BrowserFactory.Create();
                browserView = new WPFBrowserView(browser);

                browser.DialogHandler = new SampleDialogHandler(this);

                Content = browserView;

                Width = 1024;
                Height = 768;
                this.Loaded += WindowMain_Loaded;
            }

            void WindowMain_Loaded(object sender, RoutedEventArgs e)
            {
                browserView.Browser.LoadHTML("http://jkorpela.fi/forms/file.html");
            }

            public class SampleDialogHandler : WPFDefaultDialogHandler
            {
                private Window windowMain;

                public SampleDialogHandler(Window windowMain) : base(windowMain)
                {
                    // TODO: Complete member initialization
                    this.windowMain = windowMain;
                }

                public override CloseStatus OnFileChooser(FileChooserParams parameters)
                {
                    CloseStatus returnValue = CloseStatus.CANCEL;
        
                    bool isOpenMode = parameters.Mode == FileChooserMode.Open;
                    bool isOpenMultipleMode = parameters.Mode == FileChooserMode.OpenMultiple;
                    if (isOpenMode || isOpenMultipleMode)
                    {
                        Application.Current.Dispatcher.Invoke((Action)(() =>
                        {
                            OpenFileDialog fileChooser = new OpenFileDialog();
                            fileChooser.Multiselect = isOpenMultipleMode;
                            fileChooser.Title = "Open";

                            fileChooser.FileOk += delegate
                            {
                                if (isOpenMultipleMode)
                                {
                                    string[] selectedFiles = fileChooser.FileNames;
                                    parameters.SelectedFiles = String.Join("|", selectedFiles);
                                }
                                else
                                {
                                    parameters.SelectedFiles = fileChooser.FileName;
                                }
                                returnValue = CloseStatus.OK;
                            };

                            fileChooser.ShowDialog(windowMain);
                        }));
                    }

                    return returnValue;
                }
            }
        
            [STAThread]
            public static void Main()
            {
                Application app = new Application();

                WindowMain wnd = new WindowMain();
                app.Run(wnd);

                var browser = wnd.browserView.Browser;
                wnd.browserView.Dispose();
                browser.Dispose();
            }
        }
    }
}

VB.NET

Imports System.Windows
Imports DotNetBrowser
Imports DotNetBrowser.WPF
Imports Microsoft.Win32

Module Module1
    Public Class WindowMain
        Inherits Window

        Public Dim browserView As WPFBrowserView

        Public Sub New()

            Dim browser As Browser = BrowserFactory.Create()
            browserView = New WPFBrowserView(browser)

            browser.DialogHandler = New SampleDialogHandler(Me)

            Content = browserView

            Width = 1024
            Height = 768
            AddHandler Me.Loaded, AddressOf WindowMain_Loaded
        End Sub

        Private Sub WindowMain_Loaded(sender As Object, e As RoutedEventArgs)
            browserView.Browser.LoadURL("http://jkorpela.fi/forms/file.html")
        End Sub

        Public Class SampleDialogHandler
            Inherits WPFDefaultDialogHandler

            Private windowMain As Window

            Public Sub New(windowMain As Window)
                MyBase.New(windowMain)
                Me.windowMain = windowMain
            End Sub

            Public Overloads Function OnFileChooser(ByVal parameters As FileChooserParams) As CloseStatus
                Dim returnValue As CloseStatus = CloseStatus.CANCEL
                Dim isOpenMode As Boolean = parameters.Mode = FileChooserMode.Open
                Dim isOpenMultipleMode As Boolean = parameters.Mode = FileChooserMode.OpenMultiple

                If isOpenMode Or isOpenMultipleMode Then
                    System.Windows.Application.Current.Dispatcher.Invoke(Sub()
                        Dim fileChooser As OpenFileDialog = New OpenFileDialog()
                        fileChooser.Multiselect = isOpenMultipleMode
                        fileChooser.Title = "Open"

                        AddHandler fileChooser.FileOk, sub()

                            If isOpenMultipleMode Then
                                Dim selectedFiles As String() = fileChooser.FileNames
                                parameters.SelectedFiles = String.Join("|", selectedFiles)
                            Else
                                parameters.SelectedFiles = fileChooser.FileName
                            End If

                            returnValue = CloseStatus.OK
                        End sub

                        fileChooser.ShowDialog(windowMain)
                    End Sub)
                End If

                Return returnValue
            End Function
        End Class
    End Class

    <STAThread>
    Sub Main()
        Dim app As Application = New Application()

        Dim wnd As WindowMain = New WindowMain()
        app.Run(wnd)

        Dim browser = wnd.browserView.Browser
        wnd.browserView.Dispose()
        browser.Dispose()
    End Sub
End Module

Plugins

Sobre Plugins

A DotNetBrowser herda a Google Chromium Plugin Architecture, mas ela pode exibir apenas plugins sem janelas, porque ela usa um componente leve para exibir páginas HTML. Windowless plugins are designed to run directly within the rendering pipeline. Right now only Flash and Silverlight supports windowless mode, so they can be displayed by DotNetBrowser.

Note: Since version 1.7, NPAPI plugins are no longer supported.
If you have to use NPAPI plugins, we recommend that you stick to DotNetBrowser versions up to 1.7

Gerenciador de Plugins

Para obter informações sobre todos os plugins instalados e disponíveis, você pode usar o método PluginManager.GetPluginsInfo():

C#

PluginManager pluginManager = browser.PluginManager;
foreach (PluginInfo pluginInfo in pluginManager.GetPluginsInfo())
{
    Console.WriteLine("Plugin name: " + pluginInfo.Name);
}

VB.NET

Dim pluginManager As PluginManager= browser.PluginManager
For Each pluginInfo As PluginInfo In pluginManager.GetPluginsInfo()
    Console.WriteLine("Plugin name: " + pluginInfo.Name)
Next

Para ativar/desativar o plugin especificado registre sua própria implementação PluginFilter:

C#

class CustomPluginFilter : PluginFilter
{
    public bool IsPluginAllowed(PluginInfo pluginInfo)
    {
        return pluginInfo.MimeTypes.Contains("application/pdf");
    }
}

pluginManager.PluginFilter = new CustomPluginFilter();

VB.NET

Class CustomPluginFilter
    Implements PluginFilter

    Public Function IsPluginAllowed(pluginInfo As PluginInfo) As Boolean Implements PluginFilter.IsPluginAllowed
        Return pluginInfo.MimeTypes.Contains("application/pdf")
    End Function
End Class

pluginManager.PluginFilter = New CustomPluginFilter()

Agente de usuário

A cadeia de caracteres do agente de usuário pode ser modificada apenas uma vez, antes de criar quaisquer instâncias Browser. Você pode fornecer sua própria cadeia de caracteres do agente de usando o método BrowserPreferences.SetUserAgent(String userAgent):

C#

BrowserPreferences.SetUserAgent("My User Agent String");

VB.NET

BrowserPreferences.SetUserAgent("My User Agent String")

Exemplo

MainWindow.xaml

<Window x:Class="WPF.UserAgent.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid Name="mainLayout">
        
    </Grid>
</Window>

C#

MainWindow.xaml.cs

using System;
using System.IO;
using DotNetBrowser;
using DotNetBrowser.WPF;
using System.Windows;

namespace WPF.UserAgent
{
    public partial class MainWindow : Window
    {
        Browser browser;
        WPFBrowserView browserView;

        public MainWindow()
        {
            BrowserPreferences.SetUserAgent("My User Agent String");
            InitializeComponent();

            browser = BrowserFactory.Create();
            browserView = new WPFBrowserView(browser);
            mainLayout.Children.Add(browserView);

            browser.UserAgent = "Modified User Agent String";

            browserView.Browser.LoadURL("http://whatsmyuseragent.com/");
        }
    }
}

VB.NET

MainWindow.xaml.vb

Imports DotNetBrowser
Imports DotNetBrowser.WPF

Namespace WPF.UserAgent
    Class MainWindow
        Dim browser As Browser
        Dim browserView As WPFBrowserView

        Public Sub New()
            BrowserPreferences.SetUserAgent("My User Agent String")
            InitializeComponent()
            browser = BrowserFactory.Create()
            browserView = New WPFBrowserView(browser)
            mainLayout.Children.Add(browserView)
            browser.UserAgent = "Modified User Agent String"
            browserView.Browser.LoadURL("http://whatsmyuseragent.com/")
        End Sub
    End Class
End Namespace