Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
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:
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.