Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Remarque
Ceci n’est pas la dernière version de cet article. Pour la version actuelle, consultez la version .NET 11 de cet article.
Avertissement
Cette version d'ASP.NET Core n'est plus prise en charge. Pour plus d’informations, consultez la stratégie de support .NET et .NET Core. Pour la version actuelle, consultez la version .NET 10 de cet article.
Les appels entre .NET et JavaScript nécessitent une surcharge supplémentaire, car :
- Les appels sont asynchrones.
- Les paramètres et les valeurs de retour sont sérialisés au format JSON pour fournir un mécanisme de conversion facile à comprendre entre les types .NET et JavaScript.
En outre, pour les applications côté Blazor serveur, ces appels sont passés sur le réseau.
Éviter les appels trop fins
Étant donné que chaque appel implique une surcharge, il peut être utile de réduire le nombre d’appels. Considérez le code suivant, qui stocke une collection d’éléments localStoragedans le navigateur :
private async Task StoreAllInLocalStorage(IEnumerable<TodoItem> items)
{
foreach (var item in items)
{
await JS.InvokeVoidAsync("localStorage.setItem", item.Id,
JsonSerializer.Serialize(item));
}
}
L’exemple précédent effectue un appel d’interopérabilité distinct JS pour chaque élément. L’approche suivante permet plutôt de réduire l’interopérabilité JS à un seul appel :
private async Task StoreAllInLocalStorage(IEnumerable<TodoItem> items)
{
await JS.InvokeVoidAsync("storeAllInLocalStorage", items);
}
La fonction JavaScript correspondante stocke l’ensemble de la collection d’éléments sur le client :
function storeAllInLocalStorage(items) {
items.forEach(item => {
localStorage.setItem(item.id, JSON.stringify(item));
});
}
Pour les applications Blazor WebAssembly, le regroupement d’appels d’interopérabilité individuels JS en un seul appel améliore généralement significativement les performances si le composant effectue un grand nombre d’appels JS d’interopérabilité.
Envisagez l’utilisation d’appels synchrones
Appeler JavaScript à partir de .NET
Cette section s’applique uniquement aux composants côté client.
JS Les appels d’interopérabilité sont asynchrones, que le code appelé soit synchrone ou asynchrone. Les appels sont asynchrones pour s’assurer que les composants sont compatibles entre les modes de rendu côté serveur et côté client. Sur le serveur, tous les JS appels d’interopérabilité doivent être asynchrones, car ils sont envoyés via une connexion réseau.
Si vous savez que votre composant s’exécute uniquement sur WebAssembly, vous pouvez choisir d’effectuer des appels d’interopérabilité synchrones JS . Cela a légèrement moins de surcharge que d’effectuer des appels asynchrones et peut entraîner moins de cycles de rendu, car il n’y a pas d’état intermédiaire pendant l’attente des résultats.
Pour effectuer un appel synchrone de .NET vers JavaScript dans un composant côté client, effectuez un cast de IJSRuntime en IJSInProcessRuntime afin d’effectuer l’appel d’interopérabilité JS :
@inject IJSRuntime JS
...
@code {
protected override void HandleSomeEvent()
{
var jsInProcess = (IJSInProcessRuntime)JS;
var value = jsInProcess.Invoke<string>("javascriptFunctionIdentifier");
}
}
Lorsque vous travaillez avec des composants côté client dans .NET 5 ou une version ultérieure, vous pouvez utiliser IJSObjectReference de manière synchrone à la place. IJSInProcessObjectReference implémente IAsyncDisposable/IDisposable et doit être supprimée pour le garbage collection afin d’empêcher une fuite de mémoire, comme l’illustre l’exemple suivant :
@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();
}
}
}
Dans l’exemple précédent, une exception JSDisconnectedException n’est pas interceptée lors de la libération du module, car il n’existe aucun circuit Blazor-SignalR susceptible d’être perdu dans une application Blazor WebAssembly. Pour plus d’informations, consultez Interopérabilité JavaScript d'ASP.NET Core Blazor (interop JS).
Appeler .NET à partir de JavaScript
Cette section s’applique uniquement aux composants côté client.
JS Les appels d’interopérabilité sont asynchrones, que le code appelé soit synchrone ou asynchrone. Les appels sont asynchrones pour s’assurer que les composants sont compatibles entre les modes de rendu côté serveur et côté client. Sur le serveur, tous les JS appels d’interopérabilité doivent être asynchrones, car ils sont envoyés via une connexion réseau.
Si vous savez que votre composant s’exécute uniquement sur WebAssembly, vous pouvez choisir d’effectuer des appels d’interopérabilité synchrones JS . Cela a légèrement moins de surcharge que d’effectuer des appels asynchrones et peut entraîner moins de cycles de rendu, car il n’y a pas d’état intermédiaire pendant l’attente des résultats.
Pour effectuer un appel synchrone de JavaScript vers .NET dans un composant côté client, utilisez DotNet.invokeMethod plutôt DotNet.invokeMethodAsyncque .
Les appels synchrones fonctionnent si :
Cette section s’applique uniquement aux composants côté client.
JS Les appels d’interopérabilité sont asynchrones, que le code appelé soit synchrone ou asynchrone. Les appels sont asynchrones pour s’assurer que les composants sont compatibles entre les modes de rendu côté serveur et côté client. Sur le serveur, tous les JS appels d’interopérabilité doivent être asynchrones, car ils sont envoyés via une connexion réseau.
Si vous savez que votre composant s’exécute uniquement sur WebAssembly, vous pouvez choisir d’effectuer des appels d’interopérabilité synchrones JS . Cela a légèrement moins de surcharge que d’effectuer des appels asynchrones et peut entraîner moins de cycles de rendu, car il n’y a pas d’état intermédiaire pendant l’attente des résultats.
Pour effectuer un appel synchrone de .NET vers JavaScript dans un composant côté client, effectuez un cast de IJSRuntime en IJSInProcessRuntime afin d’effectuer l’appel d’interopérabilité JS :
@inject IJSRuntime JS
...
@code {
protected override void HandleSomeEvent()
{
var jsInProcess = (IJSInProcessRuntime)JS;
var value = jsInProcess.Invoke<string>("javascriptFunctionIdentifier");
}
}
Lorsque vous travaillez avec des composants côté client dans .NET 5 ou une version ultérieure, vous pouvez utiliser IJSObjectReference de manière synchrone à la place. IJSInProcessObjectReference implémente IAsyncDisposable/IDisposable et doit être supprimée pour le garbage collection afin d’empêcher une fuite de mémoire, comme l’illustre l’exemple suivant :
@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();
}
}
}
Dans l’exemple précédent, une exception JSDisconnectedException n’est pas interceptée lors de la libération du module, car il n’existe aucun circuit Blazor-SignalR susceptible d’être perdu dans une application Blazor WebAssembly. Pour plus d’informations, consultez Interopérabilité JavaScript d'ASP.NET Core Blazor (interop JS).
Envisager l’utilisation d’appels sans désérialisation
Cette section s’applique uniquement aux applications Blazor WebAssembly.
Lors de l’exécution sur Blazor WebAssembly, il est possible d’effectuer des appels sans désérialisation de .NET vers JavaScript. Il s’agit d’appels synchrones qui n’effectuent pas de sérialisation JSON d’arguments ou de valeurs de retour. Tous les aspects de la gestion de la mémoire et des traductions entre les représentations .NET et JavaScript sont laissés au développeur.
Avertissement
Bien que l’utilisation de IJSUnmarshalledRuntime présente la surcharge la plus faible parmi les approches d’interopérabilité JS, les API JavaScript nécessaires pour interagir avec ces API ne sont actuellement pas documentées et sont susceptibles de subir des changements incompatibles dans les versions futures.
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");
}
}
Utiliser l’interopérabilité JavaScript [JSImport]/[JSExport]
L’interopérabilité JavaScript [JSImport]/[JSExport] pour Blazor WebAssembly les applications offre des performances et une stabilité améliorées par rapport à l’API JS d’interopérabilité des versions précédentes du framework avant ASP.NET Core dans .NET 7.
Pour plus d’informations, consultez Interopérabilité JSImport/JSExport JavaScript avec ASP.NET Core Blazor.