Le migliori pratiche per le prestazioni di interoperabilità JavaScript (Blazor interop) in ASP.NET Core JS

Annotazioni

Questa non è la versione più recente di questo articolo. Per la versione corrente, vedere la versione .NET 11 di questo articolo.

Avvertimento

Questa versione di ASP.NET Core non è più supportata. Per altre informazioni, vedere i criteri di supporto di .NET e .NET Core. Per la versione corrente, vedere la versione .NET 10 di questo articolo.

Le chiamate tra .NET e JavaScript richiedono un sovraccarico aggiuntivo perché:

  • Le chiamate sono asincrone.
  • I parametri e i valori restituiti sono serializzati in FORMATO JSON per fornire un meccanismo di conversione facile da comprendere tra i tipi .NET e JavaScript.

Inoltre, per le app sul lato Blazor server, queste chiamate vengono passate attraverso la rete.

Evitare chiamate con granularità eccessiva

Poiché ogni chiamata comporta un sovraccarico, può essere utile ridurre il numero di chiamate. Si consideri il codice seguente, che archivia una raccolta di elementi nel browser localStorage:

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

Nell'esempio precedente viene eseguita una chiamata di interoperabilità separata JS per ogni elemento. L'approccio seguente consente invece di ridurre l'uso dell'interoperabilità JS a una singola chiamata:

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

La funzione JavaScript corrispondente archivia l'intera raccolta di elementi nel client:

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

Per Blazor WebAssembly le app, il rollover di singole JS chiamate di interoperabilità in una singola chiamata in genere migliora significativamente le prestazioni solo se il componente effettua un numero elevato di JS chiamate di interoperabilità.

Prendere in considerazione l'uso di chiamate sincrone

Chiamare JavaScript da .NET

Questa sezione si applica solo ai componenti lato client.

JS le chiamate di interoperabilità sono asincrone, indipendentemente dal fatto che il codice chiamato sia sincrono o asincrono. Le chiamate sono asincrone per garantire che i componenti siano compatibili tra le modalità di rendering lato server e lato client. Nel server tutte le JS chiamate di interoperabilità devono essere asincrone perché vengono inviate tramite una connessione di rete.

Se si è certi che il componente viene eseguito solo in WebAssembly, è possibile scegliere di effettuare chiamate di interoperabilità sincrone JS . Questo comporta un sovraccarico leggermente inferiore rispetto all'esecuzione di chiamate asincrone e può comportare un minor numero di cicli di rendering perché non esiste uno stato intermedio in attesa dei risultati.

Per eseguire una chiamata sincrona da .NET a JavaScript in un componente lato client, eseguire il cast di IJSRuntime a IJSInProcessRuntime per effettuare la chiamata di interoperabilità JS.

@inject IJSRuntime JS

...

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

Quando si utilizzano i componenti lato client in .NET 5 o versioni successive, è possibile utilizzare IJSObjectReference in modo sincrono invece. IJSInProcessObjectReference implementa IAsyncDisposable/IDisposable e deve essere eliminato per l'operazione di Garbage Collection per evitare una perdita di memoria, come illustrato nell'esempio seguente:

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

Nell'esempio precedente, un JSDisconnectedException non viene intrappolato durante l'eliminazione del modulo perché in un'applicazione Blazor non c'è nessun circuito SignalRBlazor WebAssembly da disconnettere. Per ulteriori informazioni, vedere ASP.NET Core Blazor interoperabilità di JavaScript (JS interop).

Chiamare .NET da JavaScript

Questa sezione si applica solo ai componenti lato client.

JS le chiamate di interoperabilità sono asincrone, indipendentemente dal fatto che il codice chiamato sia sincrono o asincrono. Le chiamate sono asincrone per garantire che i componenti siano compatibili tra le modalità di rendering lato server e lato client. Nel server tutte le JS chiamate di interoperabilità devono essere asincrone perché vengono inviate tramite una connessione di rete.

Se si è certi che il componente viene eseguito solo in WebAssembly, è possibile scegliere di effettuare chiamate di interoperabilità sincrone JS . Questo comporta un sovraccarico leggermente inferiore rispetto all'esecuzione di chiamate asincrone e può comportare un minor numero di cicli di rendering perché non esiste uno stato intermedio in attesa dei risultati.

Per eseguire una chiamata sincrona da JavaScript a .NET in un componente lato client, usare DotNet.invokeMethod anziché DotNet.invokeMethodAsync.

Le chiamate sincrone funzionano se:

  • Il rendering del componente viene eseguito solo per l'esecuzione in WebAssembly.
  • La funzione chiamata restituisce un valore in modo sincrono. La funzione non è un async metodo e non restituisce .NET Task o JavaScript Promise.

Questa sezione si applica solo ai componenti lato client.

JS le chiamate di interoperabilità sono asincrone, indipendentemente dal fatto che il codice chiamato sia sincrono o asincrono. Le chiamate sono asincrone per garantire che i componenti siano compatibili tra le modalità di rendering lato server e lato client. Nel server tutte le JS chiamate di interoperabilità devono essere asincrone perché vengono inviate tramite una connessione di rete.

Se si è certi che il componente viene eseguito solo in WebAssembly, è possibile scegliere di effettuare chiamate di interoperabilità sincrone JS . Questo comporta un sovraccarico leggermente inferiore rispetto all'esecuzione di chiamate asincrone e può comportare un minor numero di cicli di rendering perché non esiste uno stato intermedio in attesa dei risultati.

Per eseguire una chiamata sincrona da .NET a JavaScript in un componente lato client, eseguire il cast di IJSRuntime a IJSInProcessRuntime per effettuare la chiamata di interoperabilità JS.

@inject IJSRuntime JS

...

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

Quando si utilizzano i componenti lato client in .NET 5 o versioni successive, è possibile utilizzare IJSObjectReference in modo sincrono invece. IJSInProcessObjectReference implementa IAsyncDisposable/IDisposable e deve essere eliminato per l'operazione di Garbage Collection per evitare una perdita di memoria, come illustrato nell'esempio seguente:

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

Nell'esempio precedente, un JSDisconnectedException non viene intrappolato durante l'eliminazione del modulo perché in un'applicazione Blazor non c'è nessun circuito SignalRBlazor WebAssembly da disconnettere. Per ulteriori informazioni, vedere ASP.NET Core Blazor interoperabilità di JavaScript (JS interop).

Prendere in considerazione l'uso di chiamate non marshallate.

Questa sezione si applica solo alle Blazor WebAssembly app.

Quando è in esecuzione in Blazor WebAssembly, è possibile effettuare chiamate non elaborate da .NET a JavaScript. Si tratta di chiamate sincrone che non eseguono la serializzazione JSON di argomenti o valori restituiti. Tutti gli aspetti della gestione della memoria e delle traduzioni tra le rappresentazioni .NET e JavaScript vengono lasciati allo sviluppatore.

Avvertimento

Anche se l'uso IJSUnmarshalledRuntime ha il minor sovraccarico degli JS approcci di interoperabilità, le API JavaScript necessarie per interagire con queste API non sono attualmente documentate e soggette a modifiche di rilievo nelle versioni future.

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

Usare l'interoperabilità JavaScript [JSImport]/[JSExport]

L'interoperabilità JavaScript [JSImport]/[JSExport] per Blazor WebAssembly le app offre prestazioni e stabilità migliorate rispetto all'API JS di interoperabilità nelle versioni del framework prima di ASP.NET Core in .NET 7.

Per altre informazioni, vedere Interoperabilità JSImport/JSExport JavaScript con ASP.NET Core Blazor.