ASP.NET Core Blazor Interoperabilidade JavaScript (JS interop) melhores práticas de desempenho

Observação

Esta não é a versão mais recente deste artigo. Para a versão atual, consulte a versão .NET 11 deste artigo.

Aviso

Esta versão do ASP.NET Core não tem mais suporte. Para obter mais informações, consulte a Política de Suporte do .NET e do .NET Core. Para a versão atual, consulte a versão do .NET 10 deste artigo.

As chamadas entre .NET e JavaScript exigem sobrecarga adicional porque:

  • As chamadas são assíncronas.
  • Parâmetros e valores retornados são serializados por JSON para fornecer um mecanismo de conversão fácil de entender entre tipos .NET e JavaScript.

Além disso, para aplicativos do lado Blazor do servidor, essas chamadas são passadas pela rede.

Evitar chamadas excessivamente refinadas

Como cada chamada envolve alguma sobrecarga, pode ser valioso reduzir o número de chamadas. Considere o código a seguir, que armazena uma coleção de itens no navegador:localStorage

private async Task StoreAllInLocalStorage(IEnumerable<TodoItem> items)
{
    foreach (var item in items)
    {
        await JS.InvokeVoidAsync("localStorage.setItem", item.Id, 
            JsonSerializer.Serialize(item));
    }
}

O exemplo anterior faz uma chamada de interoperabilidade separada JS para cada item. Em vez disso, a abordagem a seguir reduz a interoperabilidade JS a uma única chamada:

private async Task StoreAllInLocalStorage(IEnumerable<TodoItem> items)
{
    await JS.InvokeVoidAsync("storeAllInLocalStorage", items);
}

A função JavaScript correspondente armazena toda a coleção de itens no cliente:

function storeAllInLocalStorage(items) {
  items.forEach(item => {
    localStorage.setItem(item.id, JSON.stringify(item));
  });
}

Para aplicativosBlazor WebAssembly, transformar chamadas de interoperabilidade individuaisJS em uma única chamada geralmente só melhora significativamente o desempenho se o componente fizer um grande número de chamadas de interoperabilidadeJS.

Considere o uso de chamadas síncronas

Chamar JavaScript do .NET

Esta seção só se aplica a componentes do lado do cliente.

JS as chamadas de interoperabilidade são assíncronas, independentemente de o código chamado ser síncrono ou assíncrono. As chamadas são assíncronas para garantir que os componentes sejam compatíveis entre os modos de renderização do lado do servidor e do cliente. No servidor, todas as JS chamadas de interoperabilidade devem ser assíncronas porque são enviadas por uma conexão de rede.

Se você souber com certeza que seu componente só é executado no WebAssembly, você pode optar por fazer chamadas de interoperabilidade síncronas JS . Isso tem um pouco menos sobrecarga do que fazer chamadas assíncronas e pode resultar em menos ciclos de renderização porque não há estado intermediário enquanto aguarda resultados.

Para fazer uma chamada síncrona do .NET para o JavaScript em um componente do lado do cliente, converta IJSRuntime em IJSInProcessRuntime para fazer a chamada de interoperabilidade de JS:

@inject IJSRuntime JS

...

@code {
    protected override void HandleSomeEvent()
    {
        var jsInProcess = (IJSInProcessRuntime)JS;
        var value = jsInProcess.Invoke<string>("javascriptFunctionIdentifier");
    }
}

Ao trabalhar com IJSObjectReference no .NET 5 ou componentes do lado do cliente posteriores, você pode usar IJSInProcessObjectReference de maneira síncrona. IJSInProcessObjectReference implementa IAsyncDisposable/IDisposable e deve ser descartado para coleta de lixo para evitar um vazamento de memória, como demonstra o exemplo a seguir:

@inject IJSRuntime JS
@implements IDisposable

...

@code {
    ...
    private IJSInProcessObjectReference? module;

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender)
        {
            var jsInProcess = (IJSInProcessRuntime)JS;
            module = await jsInProcess.Invoke<IJSInProcessObjectReference>("import", 
                "./scripts.js");
            var value = module.Invoke<string>("javascriptFunctionIdentifier");
        }
    }

    ...

    void IDisposable.Dispose()
    {
        if (module is not null)
        {
            await module.Dispose();
        }
    }
}

No exemplo anterior, a JSDisconnectedException não é preso durante o descarte do módulo porque não há nenhum Blazor-SignalR circuito em um aplicativo Blazor WebAssembly para perder. Para obter mais informações, confira Interoperabilidade com JavaScript no ASP.NET Core Blazor(JSinterop).

Chamar .NET do JavaScript

Esta seção apenas se aplica a componentes do lado do cliente.

JS as chamadas de interoperabilidade são assíncronas, independentemente de o código chamado ser síncrono ou assíncrono. As chamadas são assíncronas para garantir que os componentes sejam compatíveis entre os modos de renderização do lado do servidor e do cliente. No servidor, todas as JS chamadas de interoperabilidade devem ser assíncronas porque são enviadas por uma conexão de rede.

Se você souber com certeza que seu componente só é executado no WebAssembly, você pode optar por fazer chamadas de interoperabilidade síncronas JS . Isso tem um pouco menos sobrecarga do que fazer chamadas assíncronas e pode resultar em menos ciclos de renderização porque não há estado intermediário enquanto aguarda resultados.

Para fazer uma chamada síncrona de JavaScript para .NET em um componente do lado do cliente, use DotNet.invokeMethod em vez de DotNet.invokeMethodAsync.

Chamadas síncronas funcionarão se:

  • O componente só é renderizado para execução no WebAssembly.
  • A função chamada retorna um valor de forma síncrona. A função não é um async método e não retorna um .NET Task ou JavaScript Promise.

Esta seção só se aplica a componentes do lado do cliente.

JS as chamadas de interoperabilidade são assíncronas, independentemente de o código chamado ser síncrono ou assíncrono. As chamadas são assíncronas para garantir que os componentes sejam compatíveis entre os modos de renderização do lado do servidor e do cliente. No servidor, todas as JS chamadas de interoperabilidade devem ser assíncronas porque são enviadas por uma conexão de rede.

Se você souber com certeza que seu componente só é executado no WebAssembly, você pode optar por fazer chamadas de interoperabilidade síncronas JS . Isso tem um pouco menos sobrecarga do que fazer chamadas assíncronas e pode resultar em menos ciclos de renderização porque não há estado intermediário enquanto aguarda resultados.

Para fazer uma chamada síncrona do .NET para o JavaScript em um componente do lado do cliente, converta IJSRuntime em IJSInProcessRuntime para fazer a chamada de interoperabilidade de JS:

@inject IJSRuntime JS

...

@code {
    protected override void HandleSomeEvent()
    {
        var jsInProcess = (IJSInProcessRuntime)JS;
        var value = jsInProcess.Invoke<string>("javascriptFunctionIdentifier");
    }
}

Ao trabalhar com IJSObjectReference no .NET 5 ou componentes do lado do cliente posteriores, você pode usar IJSInProcessObjectReference de maneira síncrona. IJSInProcessObjectReference implementa IAsyncDisposable/IDisposable e deve ser descartado para coleta de lixo para evitar um vazamento de memória, como demonstra o exemplo a seguir:

@inject IJSRuntime JS
@implements IDisposable

...

@code {
    ...
    private IJSInProcessObjectReference? module;

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender)
        {
            var jsInProcess = (IJSInProcessRuntime)JS;
            module = await jsInProcess.Invoke<IJSInProcessObjectReference>("import", 
                "./scripts.js");
            var value = module.Invoke<string>("javascriptFunctionIdentifier");
        }
    }

    ...

    void IDisposable.Dispose()
    {
        if (module is not null)
        {
            await module.Dispose();
        }
    }
}

No exemplo anterior, a JSDisconnectedException não é preso durante o descarte do módulo porque não há nenhum Blazor-SignalR circuito em um aplicativo Blazor WebAssembly para perder. Para obter mais informações, confira Interoperabilidade com JavaScript no ASP.NET Core Blazor(JSinterop).

Considere o uso de chamadas não solicitadas

Esta seção se aplica apenas a aplicativos Blazor WebAssembly.

Ao executar no Blazor WebAssembly, é possível fazer chamadas com unmarshaling do .NET para o JavaScript. Essas são chamadas síncronas que não realizam a serialização JSON dos argumentos ou dos valores de retorno. Todos os aspectos do gerenciamento de memória e traduções entre representações .NET e JavaScript são deixados para o desenvolvedor.

Aviso

Embora o uso de IJSUnmarshalledRuntime tenha a menor sobrecarga das abordagens de interoperabilidade JS, as APIs JavaScript necessárias para interagir com essas APIs não estão documentadas atualmente e estão sujeitas a alterações interruptivas nas versões futuras.

function jsInteropCall() {
  return BINDING.js_to_mono_obj("Hello world");
}
@inject IJSRuntime JS

@code {
    protected override void OnInitialized()
    {
        var unmarshalledJs = (IJSUnmarshalledRuntime)JS;
        var value = unmarshalledJs.InvokeUnmarshalled<string>("jsInteropCall");
    }
}

Usar interoperabilidade [JSImport]/[JSExport] JavaScript

A interoperabilidade [JSImport]/[JSExport] JavaScript para aplicativos Blazor WebAssembly oferece melhor desempenho e estabilidade em relação à API de interoperabilidade JS nas versões de estrutura antes do ASP.NET Core no .NET 7.

Para obter mais informações, consulte Interoperabilidade de JSImport/JSExport de JavaScript com o ASP.NET Core Blazor.