Guias

List icon Conteúdo
Close
Introdução
Migração

Migração de 1.x para 2.0

A versão 2.0 do DotNetBrowser traz grandes melhorias tanto para os recursos internos quanto para a API pública da biblioteca. Este guia mostra como tornar o código do seu aplicativo escrito com o DotNetBrowser versão 1.x compatível com a versão 2.0.

Visão geral

Por quê migrar?

Recomendamos que atualize o seu código para a versão mais recente, uma vez que todas as novas funcionalidades, atualizações do Chromium, suporte de novos sistemas operativos e versões do .NET Framework, correções de erros, correções de segurança, melhorias de desempenho e de utilização de memória são aplicadas sobre a versão mais recente.

Quanto tempo demora?

De acordo com a nossa experiência, a atualização para uma nova versão principal pode demorar de algumas horas a alguns dias, dependendo do número de funcionalidades que utiliza na sua aplicação. Como é habitual, recomendamos vivamente que teste o seu software após a atualização em todos os ambientes que suporta.

Obter ajuda

Consulte a seção Perguntas Frequentes no final deste guia. Talvez a resposta à sua pergunta já esteja aí.

Caso não tenha encontrado a resposta neste guia e necessite de assistência com a migração, por favor, contate-nos. Ficaremos felizes em ajudar.

Principais alterações

API e arquitetura

Na versão 2.0 do DotNetBrowser, a arquitetura da biblioteca foi melhorada. Agora o DotNetBrowser permite-lhe criar duas instâncias absolutamente independentes do IBrowser e controlar o seu ciclo de vida. Juntamente com esta alteração da arquitetura interna, a API pública foi melhorada e alargada com novas funcionalidades.

Consulte a seção Mapeamento para saber como a funcionalidade principal da versão 1.x é mapeada para a versão 2.0.

Requisitos do sistema

A partir desta versão, o DotNetBrowser não suporta mais o .NET Framework 4.0. Os requisitos de sistema atuais estão disponíveis aqui.

Montagens

A estrutura da biblioteca mudou. Agora, a biblioteca é composta pelas seguintes montagens:

  • DotNetBrowser.dll — classes e interfaces de dados;
  • DotNetBrowser.Core.dll — a implementação central;
  • DotNetBrowser.Logging.dll — a implementação da API de registro do DotNetBrowser;
  • DotNetBrowser.WinForms.dll — classes e interfaces para incorporação numa aplicação WinForms;
  • DotNetBrowser.Wpf.dll — classes e interfaces para incorporação numa aplicação WPF;
  • DotNetBrowser.Chromium.Win-x86.dll — Binários do Chromium de 32 bits para Windows;
  • DotNetBrowser.Chromium.Win-x64.dll — Binários do Chromium de 64 bits para Windows.

Conceitos básicos

A forma de criar e eliminar vários objetos foi alterada na nova API.

Para criar um objeto IEngine utilize o método estático EngineFactory.Create():

IEngine engine = EngineFactory.Create(options);

Dim engine As IEngine = EngineFactory.Create(options)

Para criar um objeto de dados imutável, utilize o método <Object>.Builder.Build():

EngineOptions engineOptions = new EngineOptions.Builder()
{
    Language = Language.EnglishUs
}.Build();

Dim engineOptions As EngineOptions = New EngineOptions.Builder() With {
    .Language = Language.EnglishUs
}.Build()

Todos os objetos que devem ser eliminados manualmente implementam a interface IDisposable, por exemplo, IBrowser. Para eliminar o objeto, chame o método IDisposable.Dispose():

browser.Dispose();

browser.Dispose()

Alguns objetos de serviço dependem de outros objetos de serviço. Quando se elimina um objeto de serviço, todos os objetos de serviço que dependem dele são eliminados automaticamente, então não é necessário eliminá-los manualmente. Consulte o guia Arquitetura para obter mais informações sobre os principais objetos e os seus princípios de interação.

Handlers

Os handlers são utilizados para processar várias chamadas de retorno do engine Chromium e modificar o seu comportamento.

v1.x

No DotNetBrowser versão 1.x, os handlers são normalmente implementados como propriedades de tipos de interface, como PrintHandler, PermissionHandler, LoadHandler, entre outros.

v2.0

No DotNetBrowser versão 2.0, todos os manipuladores são implementados como propriedades do tipo IHandler<in T> ou IHandler<in T, out TResult>, em que T é o tipo de parâmetro, TResult é o tipo de resultado. O resultado devolvido pelo handler será utilizado para notificar o engine Chromium e afetar o seu comportamento.

Para registrar e anular o regisrto de um handler, utilize os correspondentes setters e getters de propriedades.

Existem implementações por padrão da interface IHandler<in T, out TResult>:

  • A classe Handler<T, TResult> permite envolver lambdas e grupos de métodos;
  • A classe AsyncHandler<T, TResult> permite agrupar lambdas e grupos de métodos assíncronos, ou lambdas e grupos de métodos que devolvem Task<TResult>.

Em alguns casos, o engine pode parecer bloqueado até que o handler devolva o resultado. No caso de utilizar o AsyncHandler, o engine aparece bloqueado até que o resultado esteja disponível na tarefa devolvida.

Segurança de thread

A biblioteca não é thread-safe, por isso evite trabalhar com a biblioteca a partir de diferentes threads ao mesmo tempo.

Licenciamento

Na versão 2.0 do DotNetBrowser, o formato da licença e a forma como a biblioteca verifica a licença foram melhorados.

v1.x

Na versão anterior, a licença representava um arquivo de texto teamdev.licenses. Este arquivo de texto continha o texto simples da licença. Para configurar a licença, você tinha que incluir este arquivo de texto no seu projeto como um EmbeddedResource ou copiá-lo para a pasta de trabalho da aplicação .NET.

A licença do projeto estava associada a um nome de tipo totalmente qualificado (por exemplo, Company.Product.MyClass). Poderia ser qualquer classe da sua aplicação. O único requisito é que esta classe fosse incluída no classpath da sua aplicação .NET onde utilizou o DotNetBrowser.

v2.0

Agora, a biblioteca requer uma chave de licença que representa uma cadeia de caracteres com uma combinação de letras e dígitos. Você pode adicionar a licença ao seu projeto através da API.

Também é possível colocar esta cadeia de caracteres num arquivo de texto com o nome dotnetbrowser.license e incluir este arquivo de texto no seu projeto como um EmbeddedResource ou copiá-lo para a pasta de trabalho da aplicação .NET.

A licença do projeto está agora associada a um namespace. Espera-se que o namespace esteja no formato Company.Product.Namespace. Ele deve ser um namespace de nível superior para as classes em que é criada uma instância do IEngine.

Por exemplo, se a licença do Projeto estiver vinculada ao namespace Company.Product, então você pode criar instâncias de IEngine apenas nas classes localizadas neste namespace ou em seus namespaces internos, por exemplo. Empresa.Produto.Namespace.

O IEngine foi introduzido no DotNetBrowser 2. Recomendamos que consulte o guia que descreve a nova arquitetura, como criar um IEngine e gerir vários ciclos de vida de IBrowser.

Você pode trabalhar com a instância criada do IEngine e fazer chamadas à API da biblioteca a partir das classes localizadas em outros namespaces sem quaisquer restrições.

Funcionalidade abandonada

A partir desta versão, o DotNetBrowser não suporta mais o .NET Framework 4.

Na nova versão, a seguinte funcionalidade foi temporariamente abandonada:

  • Notifications API;
  • PasswordManager API;
  • API de impressão (restaurada em DotNetBrowser 2.4);
  • API de cache de aplicativos HTML5;
  • Apresentação da caixa de diálogo BeforeUnload quando eliminando IBrowser(restaurada em DotNetBrowser 2.5);
  • API Arrasta e Soltar IDataObject (restaurada em DotNetBrowser 2.3);
  • Interceção de eventos Arrastar e Soltar (restaurado em DotNetBrowser 2.3);
  • Interceção e supressão de eventos de toque e de gestos (interceção de eventos de toque restaurada em DotNetBrowser 2.11).

Nas próximas versões, iremos fornecer alternativas às características acima mencionadas.

Mapeamento

Nesta seção, descrevemos como a principal funcionalidade do DotNetBrowser versão 1.x é mapeada para a versão 2.0.

Engine

Criando um engine

1.x

O IEngine não faz parte da API pública. É criado internamente quando a primeira instância do Browser é criada na aplicação. Apenas um IEngine pode ser criado e utilizado na aplicação.

2.0

O IEngine faz agora parte da API pública. É possível criar e utilizar várias instâncias do Engine na aplicação. Para criar uma instância do Engine com as opções necessárias, utilize o exemplo de código abaixo:

IEngine engine = EngineFactory.Create(new EngineOptions.Builder
{
    // O idioma usado nas páginas de erro padrão e GUI.
    Language = Language.EnglishUs,
    // O caminho absoluto para a pasta onde os dados 
    // tais como cache, cookies, histórico, cache GPU, armazenamento local 
    //, links visitados, dados web, verificação ortográfica 
    // arquivos de dicionário, etc. são armazenados.
    UserDataDirectory = @"C:\Users\Me\DotNetBrowser"
}.Build());

Dim engine As IEngine = EngineFactory.Create(New EngineOptions.Builder With {
    ' O idioma usado nas páginas de erro padrão e na GUI.
    .Language = Language.EnglishUs,
    ' O caminho absoluto para a pasta onde estão armazenados os dados 
    ' tais como cache, cookies, histórico, cache GPU, armazenamento local 
    ', links visitados, dados Web, arquivos de dicionário de verificação ortográfica 
    ', etc.
    .UserDataDirectory = "C:\Users\Me\DotNetBrowser"
}.Build())

Cada instância do IEngine executa um processo nativo separado onde o Chromium com as opções fornecidas é criado e inicializado. O processo nativo comunica com o processo .NET utilizando a ponte IPC (Inter-Process Communication). Se o processo nativo for encerrado inesperadamente devido a uma falha, o processo .NET continuará a ser executado.

Você pode utilizar a seguinte notificação para saber quando o IEngine é terminado inesperadamente, para que possa recriar o Engine e restaurar as instâncias do IBrowser:

engine.Disposed += (s, e) => 
{
    long exitCode = e.ExitCode;
    if(exitCode != 0)
    {
        // Limpa todos os recursos alocados e recria o Engine.
    }
};

AddHandler engine.Disposed, Sub(s, e)
    Dim exitCode As Long = e.ExitCode
    If exitCode <> 0 Then
        ' Limpa todos os recursos alocados e recria o Engine.
    End If
End Sub

Fechando o Engine

1.x

O IEngine é eliminado automaticamente quando a última instância do Browser é eliminada na aplicação.

2.0

O IEngine deve ser eliminado manualmente utilizando o método Dispose() quando já não for necessário:

engine.Dispose();

engine.Dispose()

Quando o IEngine é eliminado, todas as suas instâncias do IBrowser são eliminadas automaticamente. Qualquer tentativa de utilizar um IEngine já eliminado conduz a uma exceção.

Para saber quando o IEngine é eliminado, utilize o seguinte evento:

engine.Disposed += (s, e) => {};

AddHandler engine.Disposed, Sub(s, e)
End Sub

Criando um navegador

1.x

Browser browser = BrowserFactory.Create();

Dim browser As Browser = BrowserFactory.Create()

2.0

IBrowser browser = engine.CreateBrowser();

Dim browser As IBrowser = engine.CreateBrowser()

Criando um navegador com opções

1.x

BrowserContextParams parameters = new BrowserContextParams(@"C:\Users\Me\DotNetBrowser") 
{ 
    StorageType = StorageType.MEMORY 
};
BrowserContext context = new BrowserContext(parameters);
Browser browser = BrowserFactory.Create(context, BrowserType.LIGHTWEIGHT);

Dim parameters As BrowserContextParams = 
    New BrowserContextParams("C:\Users\Me\DotNetBrowser") With {
        .StorageType = StorageType.MEMORY
    }
Dim context As BrowserContext = New BrowserContext(parameters)
Dim browser As Browser = BrowserFactory.Create(context, BrowserType.LIGHTWEIGHT)

2.0

A funcionalidade BrowserContext foi transferida para IEngine. Assim, o mesmo código deve ser substituído pelo exemplo de código abaixo:

IEngine engine = EngineFactory.Create(new EngineOptions.Builder
{
    IncognitoEnabled = true,
    RenderingMode = RenderingMode.OffScreen,
    UserDataDirectory = @"C:\Users\Me\DotNetBrowser"
}.Build());
IBrowser browser = engine.CreateBrowser();

Dim engine As IEngine = EngineFactory.Create(New EngineOptions.Builder With {
    .IncognitoEnabled = True,
    .RenderingMode = RenderingMode.OffScreen,
    .UserDataDirectory = "C:\Users\Me\DotNetBrowser"
}.Build())
Dim browser As IBrowser = engine.CreateBrowser()

Eliminando um navegador

1.x

browser.Dispose();

browser.Dispose()

2.0

browser.Dispose();

browser.Dispose()

Responsivo/não responsivo

1.x

browser.RenderResponsiveEvent += (s, e ) => {};
browser.RenderUnresponsiveEvent += (s, e) => {};

AddHandler browser.RenderResponsiveEvent, Sub(s, e)
End Sub
AddHandler browser.RenderUnresponsiveEvent, Sub(s, e)
End Sub

2.0

browser.BrowserBecameResponsive += (s, e ) => {};
browser.BrowserBecameUnresponsive += (s, e) => {};

AddHandler browser.BrowserBecameResponsive, Sub(s, e)
End Sub
AddHandler browser.BrowserBecameUnresponsive, Sub(s, e)
End Sub

BrowserView

No DotNetBrowser versão 1.x, a criação de um BrowserView com seu construtor padrão leva à inicialização de uma instância vinculada do Browser no mesmo thread. Como resultado, o thread principal da interface do usuário pode aparecer bloqueada até que a instância do Browser seja criada e inicializada, e isso pode levar um tempo significativo.

No DotNetBrowser versão 2.0, a criação de uma implementação IBrowserView com o seu construtor predefinido cria um controlo de IU que não está inicialmente ligado a qualquer browser. A ligação com uma instância específica do IBrowser é estabelecida quando necessário, chamando o método de extensão InitializeFrom(IBrowser).

As implementações do IBrowserView não descartam as instâncias IBrowser ou IEngine conectadas quando o aplicativo é fechado. Como resultado, o navegador e o engine aparecerão vivos mesmo depois de todas as janelas da aplicação estarem fechadas e impedirão que a aplicação termine. Para lidar com este caso, elimine as instâncias IBrowser ou IEngine durante o encerramento da aplicação.

Criando o WinForms BrowserView

1.x

using DotNetBrowser.WinForms;
// ...
BrowserView view = new WinFormsBrowserView();

Imports DotNetBrowser.WinForms
' ...
Dim view As BrowserView = New WinFormsBrowserView()

2.0

using DotNetBrowser.WinForms;
// ...
BrowserView view = new BrowserView();
view.InitializeFrom(browser);

Imports DotNetBrowser.WinForms
' ...
Dim view As BrowserView = New BrowserView()
view.InitializeFrom(browser)

Criando o WPF BrowserView

1.x

using DotNetBrowser.WPF;
// ...
BrowserView view = new WPFBrowserView(browser);

Imports DotNetBrowser.WPF
' ...
Dim view As BrowserView = New WPFBrowserView()

2.0

using DotNetBrowser.Wpf;
// ...
BrowserView view = new BrowserView();
view.InitializeFrom(browser);

Imports DotNetBrowser.Wpf
' ...
Dim view As BrowserView = New BrowserView()
view.InitializeFrom(browser)

Frame

Trabalhar com frame

1.x

Uma página Web pode ser constituída pelo frame principal e por vários subframes. Para efetuar uma operação com um frame, passe o identificador do frame para o método correspondente:

// Obtém o HTML do frame principal.
browser.GetHTML();

// Obter HTML de todos os frames.
foreach (long frameId in browser.GetFramesIds()) {
    string html = browser.GetHTML(frameId);
}

' Obter HTML do frame principal.
browser.GetHTML()

' Obter HTML de todos os frames.
For Each frameId As Long In browser.GetFramesIds()
    Dim html As String = browser.GetHTML(frameId)
Next

2.0

O IFrame faz agora parte da API pública. Você pode trabalhar com o frame através da instância IFrame:

// Obtém o HTML do frame principal se ele existir.
string html = browser.MainFrame?.Html;

// Obter HTML de todos os frames.
foreach (IFrame frame in browser.AllFrames)
{
    string html = frame.Html;
}

' Obtém o HTML do frame principal se ele existir.
Dim html As String = browser.MainFrame?.Html

' Obter o HTML de todos os frames.
For Each frame As IFrame In browser.AllFrames
    Dim html As String = frame.Html
Next

Carregando URL

1.x

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

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

2.0

browser.Navigation.LoadUrl("https://www.google.com");

browser.Navigation.LoadUrl("https://www.google.com")

Carregamento de HTML

1.x

browser.LoadHTML("<html><body></body></html>");

browser.LoadHTML("<html><body></body></html>")

2.0

browser.MainFrame?.LoadHtml("<html><body></body></html>"));

browser.MainFrame?.LoadHtml("<html><body></body></html>"))

Eventos de navegação

Iniciar o carregamento

1.x

browser.StartLoadingFrameEvent += (s, e) =>
{
    string url = e.ValidatedURL;
};

AddHandler browser.StartLoadingFrameEvent, Sub(s, e)
    Dim url As String = e.ValidatedURL
End Sub

2.0

browser.Navigation.NavigationStarted += (s, e) => 
{
    string url = e.Url;
};

AddHandler browser.Navigation.NavigationStarted, Sub(s, e)
    Dim url As String = e.Url
End Sub

Terminar o carregamento

1.x

browser.FinishLoadingFrameEvent+= (s, e) =>
{
    string html = browser.GetHTML(e.FrameId);
};

AddHandler browser.FinishLoadingFrameEvent, Sub(s, e)
    Dim html As String = browser.GetHTML(e.FrameId)
End Sub

2.0

browser.Navigation.FrameLoadFinished += (s, e) =>
{
    string html = e.Frame.Html;
};

AddHandler browser.Navigation.FrameLoadFinished, Sub(s, e)
    Dim html As String = e.Frame.Html
End Sub

Falha no carregamento

1.x

browser.FailLoadingFrameEvent += (s, e) => 
{
    NetError errorCode = e.ErrorCode;
};

AddHandler browser.FailLoadingFrameEvent, Sub(s, e)
    Dim errorCode As NetError = e.ErrorCode
End Sub

2.0

browser.Navigation.FrameLoadFailed += (s, e) => 
{
    NetError error = e.ErrorCode;
};

ou

browser.Navigation.NavigationFinished += (s, e) => 
{
    NetError error = e.ErrorCode;
};

AddHandler browser.Navigation.FrameLoadFailed, Sub(s, e)
    Dim errorCode As NetError = e.ErrorCode
End Sub

or

AddHandler browser.Navigation.NavigationFinished, Sub(s, e)
    Dim errorCode As NetError = e.ErrorCode
End Sub

Rede

Configurar o User-Agent

1.x

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

BrowserPreferences.SetUserAgent("My User-Agent")

2.0

IEngine engine = EngineFactory.Create(new EngineOptions.Builder
{
    UserAgent = "My User-Agent"
}
.Build());

Dim engine As IEngine = EngineFactory.Create(New EngineOptions.Builder With {
    .UserAgent = "My User-Agent"
}.Build())

Configuração de Accept-Language

1.x

browserContext.AcceptLanguage = "fr, en-gb;q=0.8, en;q=0.7";

browserContext.AcceptLanguage = "fr, en-gb;q=0.8, en;q=0.7"

2.0

engine.Network.AcceptLanguage = "fr, en-gb;q=0.8, en;q=0.7";

engine.Network.AcceptLanguage = "fr, en-gb;q=0.8, en;q=0.7"

Configurando o proxy

1.x

ProxyConfig proxyConfig = browserContext.ProxyConfig;
browserContext.ProxyConfig = new CustomProxyConfig("http-proxy-server:80");

Dim proxyConfig As ProxyConfig = browserContext.ProxyConfig
browserContext.ProxyConfig = New CustomProxyConfig("http-proxy-server:80")

2.0

engine.Proxy.Settings = new CustomProxySettings("http-proxy-server:80");

engine.Proxy.Settings = New CustomProxySettings("http-proxy-server:80")

Redirecionando o pedido de URL

1.x

class MyNetworkDelegate : DefaultNetworkDelegate
{
    public override void OnBeforeURLRequest(BeforeURLRequestParams parameters)
    {
        parameters.SetURL("https://www.google.com");
    }
}
// ...
browserContext.NetworkService.NetworkDelegate = new MyNetworkDelegate();

Class MyNetworkDelegate
    Inherits DefaultNetworkDelegate

    Public Overrides Sub OnBeforeURLRequest(ByVal parameters As BeforeURLRequestParams)
        parameters.SetURL("https://www.google.com")
    End Sub
End Class
' ...
browserContext.NetworkService.NetworkDelegate = New MyNetworkDelegate()

2.0

engine.Network.SendUrlRequestHandler =
    new Handler<SendUrlRequestParameters, SendUrlRequestResponse>((e) =>
    {
        return SendUrlRequestResponse.Override("https://www.google.com");
    });

engine.Network.SendUrlRequestHandler =
        New Handler(Of SendUrlRequestParameters, SendUrlRequestResponse)(
            Function(e) SendUrlRequestResponse.Override("https://www.google.com"))

Substituindo cabeçalhos HTTP

1.x

class MyNetworkDelegate : DefaultNetworkDelegate
{
    public override void OnBeforeSendHeaders(BeforeSendHeadersParams parameters)
    {
        HttpHeadersEx headers = params.HeadersEx;
        headers.SetHeader("User-Agent", "MyUserAgent");
        headers.SetHeader("Content-Type", "text/html");
    }
}
// ...
browserContext.NetworkService.NetworkDelegate = new MyNetworkDelegate();

Class MyNetworkDelegate
    Inherits DefaultNetworkDelegate

    Public Overrides Sub OnBeforeSendHeaders(parameters As BeforeSendHeadersParams)
        Dim headers As HttpHeadersEx = params.HeadersEx
        headers.SetHeader("User-Agent", "MyUserAgent")
        headers.SetHeader("Content-Type", "text/html")
    End Sub
End Class
' ...
browserContext.NetworkService.NetworkDelegate = New MyNetworkDelegate()

2.0

engine.Network.SendHeadersHandler =
    new Handler<SendHeadersParameters, SendHeadersResponse>((e) =>
    {
        return SendHeadersResponse.OverrideHeaders(new[] {
            new HttpHeader("User-Agent", "MyUserAgent"),
            new HttpHeader("Content-Type", "text/html")
        });
    });

engine.Network.SendHeadersHandler =
    New Handler(Of SendHeadersParameters, SendHeadersResponse)(
        Function(e) SendHeadersResponse.OverrideHeaders(
            {New HttpHeader("User-Agent", "MyUserAgent"),
             New HttpHeader("Content-Type", "text/html")}))

Interceptação de pedidos de URL

1.x

class MyProtocolHandler : IProtocolHandler
{
    public IUrlResponse Handle(IUrlRequest request)
    {
        string html = "<html><body><p>Olá!</p></body></html>";
        IUrlResponse response = new UrlResponse(Encoding.UTF8.GetBytes(html));
        response.Headers.SetHeader("Content-Type", "text/html");
        return response;
    }
}
// ...
browser.Context.ProtocolService.Register("https", new MyProtocolHandler());

Class MyProtocolHandler
    Inherits IProtocolHandler

    Public Function Handle(ByVal request As IUrlRequest) As IUrlResponse
        Dim html As String = "<html><body><p>Olá!</p></body></html>"
        Dim response As IUrlResponse = New UrlResponse(Encoding.UTF8.GetBytes(html))
        response.Headers.SetHeader("Content-Type", "text/html")
        Return response
    End Function
End Class
' ...
browser.Context.ProtocolService.Register("https", New MyProtocolHandler())

2.0

network.InterceptRequestHandler =
    new Handler<InterceptRequestParameters, InterceptRequestResponse>(p =>
    {
        if (!p.UrlRequest.Url.StartsWith("https"))
        {
            return InterceptRequestResponse.Proceed();
        }

        UrlRequestJobOptions options = new UrlRequestJobOptions
        {
            Headers = new List<HttpHeader>
            {
                new HttpHeader("Content-Type", "text/plain"),
                new HttpHeader("Content-Type", "charset=utf-8")
            }
        };
        UrlRequestJob job = network.CreateUrlRequestJob(p.UrlRequest, options);

        Task.Run(() =>
        {
            // O processamento do pedido é efetuado numa thread em segundo plano
            // para evitar o congelamento da página Web.
            string html = "<html><body><p>Olá!</p></body></html>";
            job.Write(Encoding.UTF8.GetBytes(html));
            job.Complete();
        });
        
        return InterceptRequestResponse.Intercept(job);
    });

network.InterceptRequestHandler =
    New Handler(Of InterceptRequestParameters, InterceptRequestResponse)(Function(p)
        If Not p.UrlRequest.Url.StartsWith("https") Then
            Return InterceptRequestResponse.Proceed()
        End If

        Dim options = New UrlRequestJobOptions With {
                .Headers = New List(Of HttpHeader) From {
                New HttpHeader("Content-Type", "text/plain"),
                New HttpHeader("Content-Type", "charset=utf-8")
                }
                }
        Dim job As UrlRequestJob = network.CreateUrlRequestJob(p.UrlRequest, options)
        Task.Run(Sub()
            ' O processamento do pedido é efetuado numa thread em segundo plano
            ' para evitar o congelamento da página Web.
            Dim html = "<html><body><p>Olá!</p></body></html>"
            job.Write(Encoding.UTF8.GetBytes(html))
            job.Complete()
        End Sub)
        Return InterceptRequestResponse.Intercept(job)
    End Function)

Autenticação

Proxy, Basic, Digest, NTLM

1.x

class MyNetworkDelegate : DefaultNetworkDelegate
{
    public override bool OnAuthRequired(AuthRequiredParams params)
    {
        if(params.IsProxy)
        {
            params.Username = "usuário";
            params.Password = "senha";
            return false;
        }
        // Cancelar pedido de autenticação.
        return true;
    }
}
// ...
browserContext.NetworkService.NetworkDelegate = new MyNetworkDelegate();

Class MyNetworkDelegate
    Inherits DefaultNetworkDelegate

    Public Overrides Function OnAuthRequired(ByVal params As AuthRequiredParams) As Boolean
        If params.IsProxy Then
            params.Username = "usuário"
            params.Password = "senha"
            Return False
        End If
        ' Cancelar o pedido de autenticação.
        Return True
    End Function
End Class
' ...
browserContext.NetworkService.NetworkDelegate = New MyNetworkDelegate()

2.0

engine.Network.AuthenticateHandler =
    new Handler<AuthenticateParameters, AuthenticateResponse>((p) =>
    {
        if (p.IsProxy)
        {
            return AuthenticateResponse.Continue("user", "password");
        }
        else
        {
            return AuthenticateResponse.Cancel();
        }
    });

engine.Network.AuthenticateHandler =
    New Handler(Of AuthenticateParameters, AuthenticateResponse)(Function(p)
        If p.IsProxy Then
            Return AuthenticateResponse.Continue("usuário", "senha")
        Else
            Return AuthenticateResponse.Cancel()
        End If
    End Function)

Certificado de cliente HTTPS

1.x

class MyDialogHandler : DialogHandler
{
    public CloseStatus OnSelectCertificate(CertificatesDialogParams parameters)
    {
        List<Certificate> certificates = parameters.Certificates;
        if (certificates.Count == 0) {
            return CloseStatus.CANCEL;
        } else {
            parameters.SelectedCertificate = certificates.LastOrDefault();
            return CloseStatus.OK;
        }
    }

}
// ...
browser.DialogHandler = new MyDialogHandler();

Class MyDialogHandler
    Inherits DialogHandler

    Public Function OnSelectCertificate(parameters As CertificatesDialogParams) As CloseStatus
        Dim certificates As List(Of Certificate) = parameters.Certificates

        If certificates.Count Is 0 Then
            Return CloseStatus.CANCEL
        Else
            parameters.SelectedCertificate = certificates.LastOrDefault()
            Return CloseStatus.OK
        End If
    End Function
    ' ...
End Class
' ...
browser.DialogHandler = New MyDialogHandler()

2.0

browser.SelectCertificateHandler
    = new Handler<SelectCertificateParameters, SelectCertificateResponse>(p =>
    {
        int count = p.Certificates.Count();
        return count == 0 ?
            SelectCertificateResponse.Cancel() :
            SelectCertificateResponse.Select(p.Certificates.Count() - 1);
    });

browser.SelectCertificateHandler =
    New Handler(Of SelectCertificateParameters, SelectCertificateResponse)(Function(p)
        Dim count As Integer = p.Certificates.Count()
        Return If (count = 0,
                   SelectCertificateResponse.Cancel(),
                   SelectCertificateResponse.Select(p.Certificates.Count() - 1))
    End Function)

Plugins

Filtrando plugins

1.x

class MyPluginFilter : PluginFilter
{
    public bool IsPluginAllowed(PluginInfo pluginInfo)
    {
        return true;
    }
}
// ...
browser.PluginManager.PluginFilter = new MyPluginFilter();

Class MyPluginFilter
    Inherits PluginFilter

    Public Function IsPluginAllowed(ByVal pluginInfo As PluginInfo) As Boolean
        Return True
    End Function
End Class
' ...
browser.PluginManager.PluginFilter = New MyPluginFilter()

2.0

engine.Plugins.AllowPluginHandler = 
    new Handler<AllowPluginParameters, AllowPluginResponse>(p =>
    {
        return AllowPluginResponse.Allow();
    });

engine.Plugins.AllowPluginHandler =
    New Handler(Of AllowPluginParameters, AllowPluginResponse)(
        Function(p) AllowPluginResponse.Allow())

DOM

Acessar um documento

1.x

DOMDocument document = browser.GetDocument();

Dim document As DOMDocument = browser.GetDocument()

2.0

IDoc document = browser.MainFrame?.Document;

Dim document As IDocument = browser.MainFrame?.Document

Eventos DOM

Trabalhar com eventos

1.x

element.AddEventListener(DOMEventType.OnClick, (s, e) =>
{
    DOMEventTarget eventTarget = e.Target;
    if (eventTarget != null) {
        // ...
    }
}, false);

element.AddEventListener(DOMEventType.OnClick, Sub(s, e)
    Dim eventTarget As DOMEventTarget = e.Target

    If eventTarget IsNot Nothing Then
        ' ...
    End If
End Sub, False)

2.0

element.Events.Click += (s, e) =>
{
    IEventTarget eventTarget = e.Event.Target;
    if (eventTarget != null)
    {
        // ...
    }
};

AddHandler element.Events.Click, Sub(s, e)
    Dim eventTarget As IEventTarget = e.Event.Target

    If eventTarget IsNot Nothing Then
        ' ...
    End If
End Sub

JavaScript

Chamando JavaScript a partir do .NET

1.x

string name = browser.ExecuteJavaScriptAndReturnValue("'Olá'")
        .AsString().Value;
double number = browser.ExecuteJavaScriptAndReturnValue("123")
        .AsNumber().Value;
bool flag = browser.ExecuteJavaScriptAndReturnValue("true")
        .AsBoolean().Value;
JSObject window = browser.ExecuteJavaScriptAndReturnValue("window")
        .AsObject();

Dim name As String = browser.ExecuteJavaScriptAndReturnValue("'Olá'") _
        .AsString().Value
Dim number As Double = browser.ExecuteJavaScriptAndReturnValue("123") _
        .AsNumber().Value
Dim flag As Boolean = browser.ExecuteJavaScriptAndReturnValue("true") _
        .AsBoolean().Value
Dim window As JSObject = browser.ExecuteJavaScriptAndReturnValue("window") _
        .AsObject()

2.0

A classe JSValue foi removida no DotNetBrowser 2.0. A conversão de tipos é agora efetuada automaticamente. É possível executar JavaScript tanto de forma síncrona, bloqueando a execução do thread atual, como de forma assíncrona:

IFrame mainFrame = browser.MainFrame;
if(mainFrame != null)
{
    // Execução com await.
    string name = await mainFrame.ExecuteJavaScript<string>("'Olá'");
    double number = await mainFrame.ExecuteJavaScript<double>("123");
    bool flag = await mainFrame.ExecuteJavaScript<bool>("true");
    IJsObject window = await mainFrame.ExecuteJavaScript<IJsObject>("window");

    // Execução síncrona que bloqueia a thread atual.
    nome = mainFrame.ExecuteJavaScript<string>("'Olá'").Result;
    number = mainFrame.ExecuteJavaScript<double>("123").Result;
    flag = mainFrame.ExecuteJavaScript<bool>("true").Result;
    window = mainFrame.ExecuteJavaScript<IJsObject>("window").Result;

    // Execução assíncrona com continuação.
    mainFrame.ExecuteJavaScript<IDocument>("document").ContinueWith(t =>{
        string baseUri = t.Result.BaseUri;
    });
}

Dim mainFrame As IFrame = browser.MainFrame

If mainFrame IsNot Nothing Then
    ' Execução com await.
    Dim name As String = Await mainFrame.ExecuteJavaScript (Of String)("'Olá'")
    Dim number As Double = Await mainFrame.ExecuteJavaScript (Of Double)("123")
    Dim flag As Boolean = Await mainFrame.ExecuteJavaScript (Of Boolean)("true")
    Dim window As IJsObject = Await mainFrame.ExecuteJavaScript (Of IJsObject)("window")

    ' Execução síncrona que bloqueia a thread atual.
    name = mainFrame.ExecuteJavaScript (Of String)("'Olá'").Result
    number = mainFrame.ExecuteJavaScript (Of Double)("123").Result
    flag = mainFrame.ExecuteJavaScript (Of Boolean)("true").Result
    window = mainFrame.ExecuteJavaScript (Of IJsObject)("window").Result

    ' Execução assíncrona com continuação.
    mainFrame.ExecuteJavaScript (Of IDocument)("document").ContinueWith(
        Sub(t)
            Dim baseUri As String = t.Result.BaseUri
        End Sub)
End If

Chamando o .NET a partir do JavaScript

1.x

No código .NET:

public class MyObject {
    public void foo(string text) {}
}
// ...
JSValue window = browser.ExecuteJavaScriptAndReturnValue("window");
if (window.IsObject()) {
    window.AsObject().SetProperty("myObject", new MyObject());
}

Public Class MyObject
    Public Sub foo(text As String)
    End Sub
End Class
' ...
Dim window As JSValue = browser.ExecuteJavaScriptAndReturnValue("window")

If window.IsObject() Then
    window.AsObject().SetProperty("myObject", New MyObject())
End If

No código JavaScript:

window.myObject.foo("Olá");

2.0

No código .NET:

public class MyObject {
    public void foo(string text) {}
}
// ...
IJsObject window = frame.ExecuteJavaScript<IJsObject>("window").Result;
window.Properties["myObject"] = new MyObject();

Public Class MyObject
    Public Sub foo(text As String)
    End Sub
End Class
' ...
Dim window As IJsObject = frame.ExecuteJavaScript(Of IJsObject)("window").Result
window.Properties("myObject") = New MyObject()

No código JavaScript:

window.myObject.foo("Olá");

Injetando JavaScript

1.x

browser.ScriptContextCreated += (sender, args) =>
{
    JSValue window = browser.ExecuteJavaScriptAndReturnValue(args.Context.FrameId, @"window");
    window.AsObject().SetProperty("myObject", new MyObject());
};

AddHandler browser.ScriptContextCreated, Sub(sender, args)
    Dim window As JSValue = 
        browser.ExecuteJavaScriptAndReturnValue(args.Context.FrameId, "window")
    window.AsObject().SetProperty("myObject", New MyObject())
End Sub

2.0

browser.InjectJsHandler = new Handler<InjectJsParameters>((args) => 
{
    IJsObject window = args.Frame.ExecuteJavaScript<IJsObject>("window").Result;
    window.Properties["myObject"] = new MyObject();
});

browser.InjectJsHandler = New Handler(Of InjectJsParameters)(Sub(args)
    Dim window As IJsObject = args.Frame.ExecuteJavaScript (Of IJsObject)("window").Result
    window.Properties("myObject") = New MyObject()
End Sub)

Eventos de console

1.x

browser.ConsoleMessageEvent += (s, args) =>
{
    string message = args.Message;
};

AddHandler browser.ConsoleMessageEvent, Sub(s, args)
    Dim message As String = args.Message
End Sub

2.0

browser.ConsoleMessageReceived += (s, args) =>
{
    string message = args.Message;
};

AddHandler browser.ConsoleMessageReceived, Sub(s, args)
    Dim message As String = args.Message
End Sub

Pop-ups

Supressão de pop-ups

1.x

class MyPopupHandler : PopupHandler
{
    public PopupContainer HandlePopup(PopupParams popupParams)
    {
        return null;
    }
}
// ...
browser.PopupHandler = new MyPopupHandler();

 Class MyPopupHandler
    Inherits PopupHandler

    Public Function HandlePopup(ByVal popupParams As PopupParams) As PopupContainer
        Return Nothing
    End Function
End Class
' ...
browser.PopupHandler = New MyPopupHandler()

2.0

browser.CreatePopupHandler = new Handler<CreatePopupParameters, CreatePopupResponse>((p) =>
{
    return CreatePopupResponse.Suppress();
});

browser.CreatePopupHandler =
    New Handler(Of CreatePopupParameters, CreatePopupResponse)(
        Function(p) CreatePopupResponse.Suppress())

Abrindo pop-ups

1.x

class MyPopupContainer : PopupContainer
{
    public void InsertBrowser(Browser browser, System.Drawing.Rectangle initialBounds)
    {
        // ...
    }
}
class MyPopupHandler : PopupHandler
{
    public PopupContainer HandlePopup(PopupParams popupParams)
    {
        return new MyPopupContainer();
    }
}
// ...
browser.PopupHandler = new MyPopupHandler();

Class MyPopupContainer
    Inherits PopupContainer

    Public Sub InsertBrowser(browser As Browser, initialBounds As Rectangle)
    ' ...
    End Sub
End Class

Class MyPopupHandler
    Inherits PopupHandler

    Public Function HandlePopup(popupParams As PopupParams) As PopupContainer
        Return New MyPopupContainer()
    End Function
End Class
' ...
browser.PopupHandler = New MyPopupHandler()

2.0

browser.CreatePopupHandler = new Handler<CreatePopupParameters, CreatePopupResponse>((p) =>
{
    return CreatePopupResponse.Create();
});
browser.OpenPopupHandler = new Handler<OpenPopupParameters>((p) =>
{
    IBrowser popup = p.PopupBrowser;
    // ...
});

browser.CreatePopupHandler =
    New Handler(Of CreatePopupParameters, CreatePopupResponse)(
        Function(p) CreatePopupResponse.Create())

browser.OpenPopupHandler = New Handler(Of OpenPopupParameters)(
    Sub(p)
        Dim popup As IBrowser = p.PopupBrowser
        ' ...
    End Sub)

Diálogos

Diálogos JavaScript

1.x

class MyDialogHandler : DialogHandler
{
    public void OnAlert(DialogParams parameters) 
    {
    }

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

    public CloseStatus OnPrompt(PromptDialogParams parameters) 
    {
        parameters.PromptText = "Text";
        return CloseStatus.OK;
    }
    // ...
}
// ...
browser.DialogHandler = new MyDialogHandler();

Class MyDialogHandler
    Inherits DialogHandler
    Public Sub OnAlert(ByVal parameters As DialogParams)
    End Sub
 
    Public Function OnConfirmation(ByVal parameters As DialogParams) As CloseStatus
        Return CloseStatus.CANCEL
    End Function
 
    Public Function OnPrompt(ByVal parameters As PromptDialogParams) As CloseStatus
        parameters.PromptText = "Text"
        Return CloseStatus.OK
    End Function
    ' ...
End Class
' ...
browser.DialogHandler = New MyDialogHandler()

2.0

browser.JsDialogs.AlertHandler = new Handler<AlertParameters>(p =>
    {
        // ...
    });
browser.JsDialogs.ConfirmHandler =
    new Handler<ConfirmParameters, ConfirmResponse>(p => 
    {
        return ConfirmResponse.Cancel();
    });
browser.JsDialogs.PromptHandler =
    new Handler<PromptParameters, PromptResponse>(p =>
    {
        return PromptResponse.SubmitText("responseText");
    });

browser.JsDialogs.AlertHandler = New Handler(Of AlertParameters)(
    Sub(p)
        ' ...
    End Sub)
browser.JsDialogs.ConfirmHandler =
    New Handler(Of ConfirmParameters, ConfirmResponse)(
        Function(p) ConfirmResponse.Cancel())
browser.JsDialogs.PromptHandler =
    New Handler(Of PromptParameters, PromptResponse)(
        Function(p) PromptResponse.SubmitText("responseText"))

Diálogos de arquivos

1.x

class FileChooserHandler : DialogHandler
{
    public CloseStatus OnFileChooser(FileChooserParams parameters) {
        FileChooserMode mode = parameters.Mode;
        if (mode == FileChooserMode.Open) {
            parameters.SelectedFiles = "file1.txt";
        }
        if (mode == FileChooserMode.OpenMultiple) {
            string[] selectedFiles = {"file1.txt", "file2.txt"};
            parameters.SelectedFiles = string.Join("|", selectedFiles);
        }
        return CloseStatus.OK;
    }
    // ...
}
// ...
browser.DialogHandler = new FileChooserHandler();

Class FileChooserHandler
    Inherits DialogHandler

    Public Function OnFileChooser(parameters As FileChooserParams) As CloseStatus
        Dim mode As FileChooserMode = parameters.Mode

        If mode Is FileChooserMode.Open Then
            parameters.SelectedFiles = "file1.txt"
        End If

        If mode Is FileChooserMode.OpenMultiple Then
            Dim selectedFiles As String() = {"file1.txt", "file2.txt"}
            parameters.SelectedFiles = String.Join("|", selectedFiles)
        End If

        Return CloseStatus.OK
    End Function
    ' ...
End Class
' ...
browser.DialogHandler = New FileChooserHandler()

2.0

browser.Dialogs.OpenFileHandler =
    new Handler<OpenFileParameters, OpenFileResponse>(p =>
    {
        return OpenFileResponse.SelectFile(Path.GetFullPath(p.DefaultFileName));
    });

browser.Dialogs.OpenMultipleFilesHandler =
    new Handler<OpenMultipleFilesParameters, OpenMultipleFilesResponse>(p =>
    {
        return OpenMultipleFilesResponse.SelectFiles(Path.GetFullPath("file1.txt"),
            Path.GetFullPath("file2.txt")));
    });

browser.Dialogs.OpenFileHandler =
    New Handler(Of OpenFileParameters, OpenFileResponse)(
        Function(p) OpenFileResponse.SelectFile(
            Path.GetFullPath(p.DefaultFileName)))

browser.Dialogs.OpenMultipleFilesHandler =
    New Handler(Of OpenMultipleFilesParameters, OpenMultipleFilesResponse)(
        Function(p) OpenMultipleFilesResponse.SelectFiles(
            Path.GetFullPath("file1.txt"),
            Path.GetFullPath("file2.txt"))))

Diálogos de cores

1.x

class ColorDialogHandler : DialogHandler
{
    private Color color;

    public ColorDialogHandler()
    {
        color = Color.White;
    }

    public CloseStatus OnColorChooser(ColorChooserParams parameters)
    {        
        parameters.Color = color;
        return CloseStatus.OK;
    }
    // ...
}
// ...
browser.DialogHandler = new ColorDialogHandler();

Class ColorDialogHandler
    Inherits DialogHandler

    Private ReadOnly color As Color

    Public Sub New()
        color = Color.White
    End Sub

    Public Function OnColorChooser(parameters As ColorChooserParams) As CloseStatus
        parameters.Color = color
        Return CloseStatus.OK
    End Function
    ' ...
End Class
' ...
browser.DialogHandler = New ColorDialogHandler()

2.0

browser.Dialogs.SelectColorHandler =
    new Handler<SelectColorParameters, SelectColorResponse>(p =>
    {
        return SelectColorResponse.SelectColor(p.DefaultColor);
    });

browser.Dialogs.SelectColorHandler =
    New Handler(Of SelectColorParameters, SelectColorResponse)(
        Function(p) SelectColorResponse.SelectColor(p.DefaultColor))

Diálogos de certificados SSL

1.x

class SelectCertificateDialogHandler : DialogHandler
{
    private const string ClientCertFile = "<cert-file>.pfx";
    private const string ClientCertPassword = "<cert-password>";
    private Certificate certificate;

    public SelectCertificateDialogHandler()
    {
        certificate = new X509Certificate2(Path.GetFullPath(ClientCertFile),
                                           ClientCertPassword,
                                           X509KeyStorageFlags.Exportable);
    }

    public CloseStatus OnSelectCertificate(CertificatesDialogParams parameters)
    {        
        parameters.SelectedCertificate = certificate;
        selectCertificateEvent.Set();
        return CloseStatus.OK;
    }
    // ...
}
// ...
browser.DialogHandler = new SelectCertificateDialogHandler();

Class SelectCertificateDialogHandler
    Inherits DialogHandler

    Private Const ClientCertFile As String = "<cert-file>.pfx"
    Private Const ClientCertPassword As String = "<cert-password>"
    Private certificate As Certificate

    Public Sub New()
        certificate = New X509Certificate2(Path.GetFullPath(ClientCertFile),
                                           ClientCertPassword,
                                           X509KeyStorageFlags.Exportable)
    End Sub

    Public Function OnSelectCertificate(ByVal p As CertificatesDialogParams) As CloseStatus
        p.SelectedCertificate = certificate
        selectCertificateEvent.Set()
        Return CloseStatus.OK
    End Function
    ' ...
End Class
' ...
browser.DialogHandler = New SelectCertificateDialogHandler()

2.0

string ClientCertFile = "<cert-file>.pfx";
string ClientCertPassword = "<cert-password>";
// ...
X509Certificate2 certificate = new X509Certificate2(Path.GetFullPath(ClientCertFile),
    ClientCertPassword,
    X509KeyStorageFlags.Exportable);
Certificate cert = new Certificate(certificate);
browser.SelectCertificateHandler
    = new Handler<SelectCertificateParameters, SelectCertificateResponse>(p =>
    {
        return SelectCertificateResponse.Select(cert);
    });

Dim ClientCertFile = "<cert-file>.pfx"
Dim ClientCertPassword = "<cert-password>"
' ...
Dim certificate = New X509Certificate2(Path.GetFullPath(ClientCertFile),
                                       ClientCertPassword,
                                       X509KeyStorageFlags.Exportable)
Dim cert = New Certificate(certificate)
browser.SelectCertificateHandler =
    New Handler(Of SelectCertificateParameters, SelectCertificateResponse)(
        Function(p) SelectCertificateResponse.Select(cert))

Impressão

Configurando a impressão

1.x

class MyPrintHandler : PrintHandler
{
    public PrintStatus OnPrint(PrintJob printJob)
    {
        PrintSettings printSettings = printJob.PrintSettings;
        printSettings.PrinterName = "Microsoft XPS Document Writer";
        printSettings.Landscape = true;
        printSettings.PrintBackgrounds = true;
        return PrintStatus.CONTINUE;
    }
}
// ...
browser.PrintHandler = new MyPrintHandler();

Class MyPrintHandler
    Inherits PrintHandler

    Public Function OnPrint(ByVal printJob As PrintJob) As PrintStatus
        Dim printSettings As PrintSettings = printJob.PrintSettings
        printSettings.PrinterName = "Microsoft XPS Document Writer"
        printSettings.Landscape = True
        printSettings.PrintBackgrounds = True
        Return PrintStatus.CONTINUE
    End Function
End Class
' ...
browser.PrintHandler = New MyPrintHandler()

2.0

A funcionalidade que permite configurar a impressão foi removida na versão 2.0 do DotNetBrowser. Ela é agora apresentada a caixa de diálogo normal de Pré-visualização da impressão, onde você pode introduzir as definições necessárias:

browser.PrintHandler =
    new Handler<PrintParameters, PrintResponse>(p =>
    {
        return PrintResponse.ShowPrintPreview();
    });

browser.PrintHandler =
    New Handler(Of PrintParameters, PrintResponse)(
        Function(p) PrintResponse.ShowPrintPreview())

Supressão da impressão

1.x

class MyPrintHandler : PrintHandler
{
    public PrintStatus OnPrint(PrintJob printJob)
    {
        return PrintStatus.CANCEL;
    }
}
// ...
browser.PrintHandler = new MyPrintHandler();

Class MyPrintHandler
    Inherits PrintHandler

    Public Function OnPrint(ByVal printJob As PrintJob) As PrintStatus
        Return PrintStatus.CANCEL
    End Function
End Class
' ...
browser.PrintHandler = New MyPrintHandler()

2.0

browser.PrintHandler =
    new Handler<PrintParameters, PrintResponse>(p =>
    {
        return PrintResponse.Cancel();
    });

browser.PrintHandler =
    New Handler(Of PrintParameters, PrintResponse)(
        Function(p) PrintResponse.Cancel())

Cache

Limpando o cache HTTP

1.x

browser.CacheStorage.ClearCache(() => 
{
    // O cache de disco HTTP foi limpo.
});

browser.CacheStorage.ClearCache(Sub()
    ' O cache de disco HTTP foi limpo.
End Sub)

2.0

await engine.HttpCache.ClearDiskCache();
// O cache de disco HTTP foi limpo.

ou

engine.HttpCache.ClearDiskCache().Wait();
// O cache de disco HTTP foi limpo.

Await engine.HttpCache.ClearDiskCache()
' O cache de disco HTTP foi limpo.

ou

engine.HttpCache.ClearDiskCache().Wait()
' O cache de disco HTTP foi limpo.

Cookies

Acessando os cookies

1.x

List<Cookie> cookies = browser.CookieStorage.GetAllCookies();

Dim cookies As List(Of Cookie) = browser.CookieStorage.GetAllCookies()

2.0

IEnumerable<Cookie> cookies = await engine.CookieStore.GetAllCookies();

ou

IEnumerable<Cookie> cookies = engine.CookieStore.GetAllCookies().Result;

Dim cookies As IEnumerable(Of Cookie) = Await engine.CookieStore.GetAllCookies()

or

Dim cookies As IEnumerable(Of Cookie) = engine.CookieStore.GetAllCookies().Result

Encerramento do processo de renderização

Cada instância do navegador é executada num processo nativo separado onde a página Web é processada.

Por vezes, este processo pode acabar inesperadamente devido a uma falha do plugin. O evento de terminação do processo de renderização pode ser utilizado para receber notificações sobre o encerramento inesperado do processo de renderização.

1.x

browser.RenderGoneEvent += (s, e) =>
{
    TerminationStatus status = e.TerminationStatus;
};

AddHandler browser.RenderGoneEvent , Sub(s, e)
    Dim status As TerminationStatus = e.TerminationStatus
End Sub

2.0

browser.RenderProcessTerminated += (s, e) =>
{
    TerminationStatus status = e.TerminationStatus;
};

AddHandler browser.RenderProcessTerminated , Sub(s, e)
    Dim status As TerminationStatus = e.TerminationStatus
End Sub

Chromium

Switches

A biblioteca não é compatível com todas as opções possíveis do Chromium. Ela permite configurar o Chromium com os switches, mas não garantimos que os switches aprovados funcionem corretamente ou de todo. Recomendamos que verifique esta funcionalidade antes de a utilizar.

1.x

BrowserPreferences.SetChromiumSwitches(
    "--<switch_name>",
    "--<switch_name>=<switch_value>"
);

BrowserPreferences.SetChromiumSwitches(
    "--<switch_name>", 
    "--<switch_name>=<switch_value>"
)

2.0

IEngine engine = EngineFactory.Create(new EngineOptions.Builder
{
    ChromiumSwitches = { "--<switch-name>", "--<switch-name>=<switch-value>" }
}.Build());

Dim engineOptions = New EngineOptions.Builder
engineOptions.ChromiumSwitches.Add("--<switch-name>")
engineOptions.ChromiumSwitches.Add("--<switch-name>=<switch-value>")

Dim engine = EngineFactory.Create(engineOptions.Build())

Chaves API

1.x

BrowserPreferences.SetChromiumVariable(
        "GOOGLE_API_KEY", "My API Key");
BrowserPreferences.SetChromiumVariable(
        "GOOGLE_DEFAULT_CLIENT_ID", "My Client ID");
BrowserPreferences.SetChromiumVariable(
        "GOOGLE_DEFAULT_CLIENT_SECRET", "My Client Secret");

BrowserPreferences.SetChromiumVariable( _
    "GOOGLE_API_KEY", "My API Key")
BrowserPreferences.SetChromiumVariable( _
    "GOOGLE_DEFAULT_CLIENT_ID", "My Client ID")
BrowserPreferences.SetChromiumVariable( _
    "GOOGLE_DEFAULT_CLIENT_SECRET", "My Client Secret")

2.0

IEngine engine = EngineFactory.Create(new EngineOptions.Builder
{
    GoogleApiKey = "<api-key>",
    GoogleDefaultClientId = "<client-id>",
    GoogleDefaultClientSecret = "<client-secret>"
}.Build());

Dim engine As IEngine = EngineFactory.Create(New EngineOptions.Builder With {
    .GoogleApiKey = "<api-key>",
    .GoogleDefaultClientId = "<client-id>",
    .GoogleDefaultClientSecret = "<client-secret>"
}.Build())

Registro

Na nova versão, melhoramos a API de registro. Leia mais sobre como configurar o registro no guia Solução de Problemas.

Perguntas Frequentes

Por quanto tempo o DotNetBrowser versão 1.x será suportado?

A versão 1.x do DotNetBrowser será suportada até fevereiro de 2021. Todas as novas funcionalidades, atualizações do Chromium, suporte dos novos sistemas operacionais e implementações .NET, diferentes melhorias, serão aplicadas sobre a versão mais recente (mainstream).

Posso atualizar para o DotNetBrowser 2 gratuitamente?

Se você já possui uma licença comercial para o DotNetBrowser 1 com uma Inscrição ativa, então você pode receber uma chave de licença comercial para o DotNetBrowser 2 gratuitamente. Contate a nossa equipa de vendas se tiver alguma questão a este respeito.

Tenho um caso não abrangido por este guia. O que devo fazer?

Recomendamos que consulte a nossa seção Guias. O DotNetBrowser versão 1.0 e versão 2.0 têm funcionalidades quase idênticas. Assim, se este guia de migração não descrever uma alternativa à funcionalidade do DotNetBrowser versão 1.0 que você utiliza, você pode encontrar uma descrição da funcionalidade semelhante nos nossos guias, onde os documentos estão agrupados por características.

Se você não encontrar a descrição da funcionalidade necessária nos guias, crie um ticket.

Go Top