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.

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

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){};

BrowserFactory

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

using DotNetBrowser;Browser 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:

Browser browser = BrowserFactory.Create();

O código acima é igual a:

Browser 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:

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

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:

BrowserContextParams params1= new BrowserContextParams("C:\\my-data1");BrowserContext context1 = new BrowserContext(params);Browser browser1 = BrowserFactory.Create(context1);BrowserContextParams params2= new BrowserContextParams("C:\\my-data2");BrowserContext context2 = new BrowserContext(params2);Browser browser2 = 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:

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.

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");        }    }}

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>

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");        }    }}

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:

Browser browser = BrowserFactory.Create();

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

// Creates Browser instance with enabled lighweight rendering modeBrowser browser = BrowserFactory.Create(BrowserType.LIGHTWEIGHT);// Creates Browser instance with enabled heavyweight rendering modeBrowser 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:

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.

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();
        }
    }
}

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:

 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();

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:

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;        }    }}

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:

<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>

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 : LoadHandler    {        public override bool CanNavigateOnBackspace() {            return false;        }    }}

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:

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

A saída será semelhante a este:

Exemplo

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();        }    }}

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:

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");        }    }}

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:

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();        }    }}

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:

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

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:

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

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:

DOMDocument document = 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:

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

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:

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

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

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

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

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");

Atributos de Elementos

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

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>");        }    }}

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.

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&lt;DOMNode&gt; 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&lt;DOMNode&gt; 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&lt;DOMNode&gt;  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();            }        }    }}

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.

// Executes the passed JavaScript code asynchronouslybrowser.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):

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

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:

JSValue document = browser.ExecuteJavaScriptAndReturnValue("document");JSValue titleValue = document.AsObject().GetProperty("title");String title = 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’:

JSValue document = 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:

JSValue document = browser.ExecuteJavaScriptAndReturnValue("document");JSValue write = 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:

JSValue array = browser.ExecuteJavaScriptAndReturnValue("['John', 'Doe', 46];");JSValue john = array.AsArray().get(0);JSValue doe = array.AsArray().get(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);            };

Exemplo

<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>

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();        }    }}

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:

JSValue window = 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:

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

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

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

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:

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.

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();        }    }}

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:

JSValue documentHeight = browser.ExecuteJavaScriptAndReturnValue(        "Math.max(document.body.scrollHeight, " +        "document.documentElement.scrollHeight, document.body.offsetHeight, " +        "document.documentElement.offsetHeight, document.body.clientHeight, " +        "document.documentElement.clientHeight);");JSValue documentWidth = 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;

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:

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:

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

Uso:

 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:

browser.DisposeEvent += delegate(object sender, DisposeEventArgs e){    synchronizationContext.Send(new SendOrPostCallback(    delegate(object state)    {        form.Controls.Clear();        form.Hide();        form.Close();    }), null);};

WPF:

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

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="WPF.DialogHandlerSample.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" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" />
    </Grid>
</Window>

MainWindow.xaml.cs

using System;using System.Windows;using System.Windows.Controls;using DotNetBrowser;using DotNetBrowser.WPF;namespace WPF.DialogHandlerSample{    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>");        }        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)        {            browserView.Dispose();            browserView.Browser.Dispose();        }    }    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 OnSelectCertificate(CertificatesDialogParams parameters)        {            return defaultHandler.OnSelectCertificate(parameters);        }    }}

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:

using DotNetBrowser;using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace CertificateSelectSample{    /// <summary>    /// Demonstrates how to handle SSL certificate selection.    /// </summary>    class Program    {        static void Main(string[] args)        {            Browser browser = BrowserFactory.Create();            browser.LoadHandler = new SampleLoadHandler();            browser.LoadURL("<URL that causes Select SSL Certificate dialog>");        }        private class SampleLoadHandler : DefaultLoadHandler        {            public override bool OnSelectCertificate(CertificatesDialogParams parameters)            {                String message = "Select a certificate to authenticate yourself to " + parameters.HostPortPair.HostPort;                List<Certificate> certificates = parameters.Certificates;                if (!(certificates.Count == 0)) {                    Object selectedValue = certificates[0];                    if (selectedValue != null) {                        parameters.SelectedCertificate = ((Certificate) selectedValue);                        return true;                    }                }                return false;            }        }    }}

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:

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

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.

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;            }        }    }}

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:

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();            }        }    }}

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:

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://www.cs.tut.fi/~jkorpela/forms/file.html");            }            private class SampleDialogHandler : DialogHandler            {                private WindowMain windowMain;                public SampleDialogHandler(WindowMain 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.Filter = parameters.Filter;                            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();            }        }    }}

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():

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

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

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

   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):

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" Closing="Window_Closing">    <Grid Name="mainLayout">    </Grid></Window>

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);            browserView.Browser.LoadURL("http://whatsmyuseragent.com/");        }        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)        {            // Dispose BrowserView when close app window.            browserView.Dispose();            browser.Dispose();        }    }}