ASP.NET Core Blazor JavaScript interoperability (JS interop)
Note
This isn't the latest version of this article. For the current release, see the .NET 8 version of this article.
This article explains general concepts on how to interact with JavaScript in Blazor apps.
A Blazor app can invoke JavaScript (JS) functions from .NET methods and .NET methods from JS functions. These scenarios are called JavaScript interoperability (JS interop).
Further JS interop guidance is provided in the following articles:
- Call JavaScript functions from .NET methods in ASP.NET Core Blazor
- Call .NET methods from JavaScript functions in ASP.NET Core Blazor
Note
JavaScript [JSImport]
/[JSExport]
interop API is available for client-side components in ASP.NET Core 7.0 or later.
For more information, see JavaScript JSImport/JSExport interop with ASP.NET Core Blazor.
Throughout this article, the terms client/client-side and server/server-side are used to distinguish locations where app code executes:
- Client/client-side
- Client-side rendering (CSR) of a Blazor Web App. The
Program
file isProgram.cs
of the client project (.Client
). Blazor script start configuration is found in theApp
component (Components/App.razor
) of the server project. Routable Interactive WebAssembly and Interactive Auto render mode components with an@page
directive are placed in the client project'sPages
folder. Place non-routable shared components at the root of the.Client
project or in custom folders based on component functionality. - A Blazor WebAssembly app. The
Program
file isProgram.cs
. Blazor script start configuration is found in thewwwroot/index.html
file.
- Client-side rendering (CSR) of a Blazor Web App. The
- Server/server-side: Interactive server-side rendering (interactive SSR) of a Blazor Web App. The
Program
file isProgram.cs
of the server project. Blazor script start configuration is found in theApp
component (Components/App.razor
). Only routable Interactive Server render mode components with an@page
directive are placed in theComponents/Pages
folder. Non-routable shared components are placed in the server project'sComponents
folder. Create custom folders based on component functionality as needed.
- Client/client-side
- The
Client
project of a hosted Blazor WebAssembly app. - A Blazor WebAssembly app.
- Blazor script start configuration is found in the
wwwroot/index.html
file. - The
Program
file isProgram.cs
.
- The
- Server/server-side
- The
Server
project of a hosted Blazor WebAssembly app. - A Blazor Server app. Blazor script start configuration is found in
Pages/_Host.cshtml
. - The
Program
file isProgram.cs
.
- The
- Client/client-side
- The
Client
project of a hosted Blazor WebAssembly app. - A Blazor WebAssembly app.
- Blazor script start configuration is found in the
wwwroot/index.html
file. - The
Program
file isProgram.cs
.
- The
- Server/server-side
- The
Server
project of a hosted Blazor WebAssembly app. - A Blazor Server app. Blazor script start configuration is found in
Pages/_Layout.cshtml
. - The
Program
file isProgram.cs
.
- The
- Client/client-side
- The
Client
project of a hosted Blazor WebAssembly app. - A Blazor WebAssembly app.
- Blazor script start configuration is found in the
wwwroot/index.html
file. - The
Program
file isProgram.cs
.
- The
- Server/server-side
- The
Server
project of a hosted Blazor WebAssembly app. - A Blazor Server app. Blazor script start configuration is found in
Pages/_Host.cshtml
. - The
Program
file isProgram.cs
.
- The
JavaScript interop abstractions and features package
The @microsoft/dotnet-js-interop
package (npmjs.com
) provides abstractions and features for interop between .NET and JavaScript (JS) code. Reference source is available in the dotnet/aspnetcore
GitHub repository (/src/JSInterop
folder). For more information, see the GitHub repository's README.md
file.
Note
Documentation links to .NET reference source usually load the repository's default branch, which represents the current development for the next release of .NET. To select a tag for a specific release, use the Switch branches or tags dropdown list. For more information, see How to select a version tag of ASP.NET Core source code (dotnet/AspNetCore.Docs #26205).
Additional resources for writing JS interop scripts in TypeScript:
- TypeScript
- Tutorial: Create an ASP.NET Core app with TypeScript in Visual Studio
- Manage npm packages in Visual Studio
Interaction with the DOM
Only mutate the DOM with JavaScript (JS) when the object doesn't interact with Blazor. Blazor maintains representations of the DOM and interacts directly with DOM objects. If an element rendered by Blazor is modified externally using JS directly or via JS Interop, the DOM may no longer match Blazor's internal representation, which can result in undefined behavior. Undefined behavior may merely interfere with the presentation of elements or their functions but may also introduce security risks to the app or server.
This guidance not only applies to your own JS interop code but also to any JS libraries that the app uses, including anything provided by a third-party framework, such as Bootstrap JS and jQuery.
In a few documentation examples, JS interop is used to mutate an element purely for demonstration purposes as part of an example. In those cases, a warning appears in the text.
For more information, see Call JavaScript functions from .NET methods in ASP.NET Core Blazor.
Asynchronous JavaScript calls
JS interop calls are asynchronous by default, regardless of whether the called code is synchronous or asynchronous. Calls are asynchronous by default to ensure that components are compatible across server-side and client-side rendering models. When adopting server-side rendering, JS interop calls must be asynchronous because they're sent over a network connection. For apps that exclusively adopt client-side rendering, synchronous JS interop calls are supported.
For more information, see the following articles:
For more information, see Call JavaScript functions from .NET methods in ASP.NET Core Blazor.
Object serialization
Blazor uses System.Text.Json for serialization with the following requirements and default behaviors:
- Types must have a default constructor,
get
/set
accessors must be public, and fields are never serialized. - Global default serialization isn't customizable to avoid breaking existing component libraries, impacts on performance and security, and reductions in reliability.
- Serializing .NET member names results in lowercase JSON key names.
- JSON is deserialized as JsonElement C# instances, which permit mixed casing. Internal casting for assignment to C# model properties works as expected in spite of any case differences between JSON key names and C# property names.
JsonConverter API is available for custom serialization. Properties can be annotated with a [JsonConverter]
attribute to override default serialization for an existing data type.
For more information, see the following resources in the .NET documentation:
- JSON serialization and deserialization (marshalling and unmarshalling) in .NET
- How to customize property names and values with
System.Text.Json
- How to write custom converters for JSON serialization (marshalling) in .NET
Blazor supports optimized byte array JS interop that avoids encoding/decoding byte arrays into Base64. The app can apply custom serialization and pass the resulting bytes. For more information, see Call JavaScript functions from .NET methods in ASP.NET Core Blazor.
Blazor supports unmarshalled JS interop when a high volume of .NET objects are rapidly serialized or when large .NET objects or many .NET objects must be serialized. For more information, see Call JavaScript functions from .NET methods in ASP.NET Core Blazor.
DOM cleanup tasks during component disposal
Don't execute JS interop code for DOM cleanup tasks during component disposal. Instead, use the MutationObserver
pattern in JavaScript (JS) on the client for the following reasons:
- The component may have been removed from the DOM by the time your cleanup code executes in
Dispose{Async}
. - During server-side rendering, the Blazor renderer may have been disposed by the framework by the time your cleanup code executes in
Dispose{Async}
.
The MutationObserver
pattern allows you to run a function when an element is removed from the DOM.
In the following example, the DOMCleanup
component:
- Contains a
<div>
with anid
ofcleanupDiv
. The<div>
element is removed from the DOM along with the rest of the component's DOM markup when the component is removed from the DOM. - Loads the
DOMCleanup
JS class from theDOMCleanup.razor.js
file and calls itscreateObserver
function to set up theMutationObserver
callback. These tasks are accomplished in theOnAfterRenderAsync
lifecycle method.
DOMCleanup.razor
:
@page "/dom-cleanup"
@rendermode InteractiveServer
@implements IAsyncDisposable
@inject IJSRuntime JS
<h1>DOM Cleanup Example</h1>
<div id="cleanupDiv"></div>
@code {
private IJSObjectReference? jsModule;
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (firstRender)
{
jsModule = await JS.InvokeAsync<IJSObjectReference>(
"import", "./Components/Pages/DOMCleanup.razor.js");
await jsModule.InvokeVoidAsync("DOMCleanup.createObserver");
}
}
async ValueTask IAsyncDisposable.DisposeAsync()
{
if (jsModule is not null)
{
await jsModule.DisposeAsync();
}
}
}
@page "/dom-cleanup"
@implements IAsyncDisposable
@inject IJSRuntime JS
<h1>DOM Cleanup Example</h1>
<div id="cleanupDiv"></div>
@code {
private IJSObjectReference? jsModule;
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (firstRender)
{
jsModule = await JS.InvokeAsync<IJSObjectReference>(
"import", "./Pages/DOMCleanup.razor.js");
await jsModule.InvokeVoidAsync("DOMCleanup.createObserver");
}
}
async ValueTask IAsyncDisposable.DisposeAsync()
{
if (jsModule is not null)
{
await jsModule.DisposeAsync();
}
}
}
In the following example, the MutationObserver
callback is executed each time a DOM change occurs. Execute your cleanup code when the if
statement confirms that the target element (cleanupDiv
) was removed (if (targetRemoved) { ... }
). It's important to disconnect and delete the MutationObserver
to avoid a memory leak after your cleanup code executes.
DOMCleanup.razor.js
placed side-by-side with the preceding DOMCleanup
component:
export class DOMCleanup {
static observer;
static createObserver() {
const target = document.querySelector('#cleanupDiv');
this.observer = new MutationObserver(function (mutations) {
const targetRemoved = mutations.some(function (mutation) {
const nodes = Array.from(mutation.removedNodes);
return nodes.indexOf(target) !== -1;
});
if (targetRemoved) {
// Cleanup resources here
// ...
// Disconnect and delete MutationObserver
this.observer && this.observer.disconnect();
delete this.observer;
}
});
this.observer.observe(target.parentNode, { childList: true });
}
}
window.DOMCleanup = DOMCleanup;
JavaScript interop calls without a circuit
This section only applies to server-side apps.
JavaScript (JS) interop calls can't be issued after a SignalR circuit is disconnected. Without a circuit during component disposal or at any other time that a circuit doesn't exist, the following method calls fail and log a message that the circuit is disconnected as a JSDisconnectedException:
- JS interop method calls
Dispose
/DisposeAsync
calls on any IJSObjectReference.
In order to avoid logging JSDisconnectedException or to log custom information, catch the exception in a try-catch
statement.
For the following component disposal example:
- The component implements IAsyncDisposable.
objInstance
is an IJSObjectReference.- JSDisconnectedException is caught and not logged.
- Optionally, you can log custom information in the
catch
statement at whatever log level you prefer. The following example doesn't log custom information because it assumes the developer doesn't care about when or where circuits are disconnected during component disposal.
async ValueTask IAsyncDisposable.DisposeAsync()
{
try
{
if (objInstance is not null)
{
await objInstance.DisposeAsync();
}
}
catch (JSDisconnectedException)
{
}
}
If you must clean up your own JS objects or execute other JS code on the client after a circuit is lost, use the MutationObserver
pattern in JS on the client. The MutationObserver
pattern allows you to run a function when an element is removed from the DOM.
For more information, see the following articles:
- Handle errors in ASP.NET Core Blazor apps: The JavaScript interop section discusses error handling in JS interop scenarios.
- ASP.NET Core Razor component lifecycle: The Component disposal with
IDisposable
andIAsyncDisposable
section describes how to implement disposal patterns in Razor components.
JavaScript location
Load JavaScript (JS) code using any of the following approaches:
Warning
Don't place a <script>
tag in a Razor component file (.razor
) because the <script>
tag can't be updated dynamically by Blazor.
Note
Documentation examples usually place scripts in a <script>
tag or load global scripts from external files. These approaches pollute the client with global functions. For production apps, we recommend placing JavaScript into separate JavaScript modules that can be imported when needed. For more information, see the JavaScript isolation in JavaScript modules section.
Note
Documentation examples place scripts into a <script>
tag or load global scripts from external files. These approaches pollute the client with global functions. Placing JavaScript into separate JavaScript modules that can be imported when needed is not supported in Blazor earlier than ASP.NET Core 5.0. If the app requires the use of JS modules for JS isolation, we recommend using ASP.NET Core 5.0 or later to build the app. For more information, use the Version dropdown list to select a 5.0 or later version of this article and see the JavaScript isolation in JavaScript modules section.
Load a script in <head>
markup
The approach in this section isn't generally recommended.
Place the JavaScript (JS) tags (<script>...</script>
) in the <head>
element markup:
<head>
...
<script>
window.jsMethod = (methodParameter) => {
...
};
</script>
</head>
Loading JS from the <head>
isn't the best approach for the following reasons:
- JS interop may fail if the script depends on Blazor. We recommend loading scripts using one of the other approaches, not via the
<head>
markup. - The page may become interactive slower due to the time it takes to parse the JS in the script.
Load a script in <body>
markup
Place the JavaScript (JS) tags (<script>...</script>
) inside the closing </body>
element after the Blazor script reference:
<body>
...
<script src="{BLAZOR SCRIPT}"></script>
<script>
window.jsMethod = (methodParameter) => {
...
};
</script>
</body>
In the preceding example, the {BLAZOR SCRIPT}
placeholder is the Blazor script path and file name. For the location of the script, see ASP.NET Core Blazor project structure.
Load a script from an external JavaScript file (.js
) collocated with a component
Collocation of JavaScript (JS) files for pages, views, and Razor components is a convenient way to organize scripts in an app.
Collocate JS files using the following filename extension conventions:
- Pages of Razor Pages apps and views of MVC apps:
.cshtml.js
. Examples:Pages/Index.cshtml.js
for theIndex
page of a Razor Pages app atPages/Index.cshtml
.Views/Home/Index.cshtml.js
for theIndex
view of an MVC app atViews/Home/Index.cshtml
.
- Razor components of Blazor apps:
.razor.js
. Example:Index.razor.js
for theIndex
component.
Collocated JS files are publicly addressable using the path to the file in the project:
Pages, views, and components from a collocated scripts file in the app:
{PATH}/{PAGE, VIEW, OR COMPONENT}.{EXTENSION}.js
- The
{PATH}
placeholder is the path to the page, view, or component. - The
{PAGE, VIEW, OR COMPONENT}
placeholder is the page, view, or component. - The
{EXTENSION}
placeholder matches the extension of the page, view, or component, eitherrazor
orcshtml
.
Razor Pages example:
A JS file for the
Index
page is placed in thePages
folder (Pages/Index.cshtml.js
) next to theIndex
page (Pages/Index.cshtml
). In theIndex
page, the script is referenced at the path in thePages
folder:@section Scripts { <script src="~/Pages/Index.cshtml.js"></script> }
When the app is published, the framework automatically moves the script to the web root. In the preceding example, the script is moved to
bin\Release\{TARGET FRAMEWORK MONIKER}\publish\wwwroot\Pages\Index.cshtml.js
, where the{TARGET FRAMEWORK MONIKER}
placeholder is the Target Framework Moniker (TFM). No change is required to the script's relative URL in theIndex
page.Blazor example:
A JS file for the
Index
component is placed next to theIndex
component (Index.razor
). In theIndex
component, the script is referenced at its path.Index.razor.js
:export function showPrompt(message) { return prompt(message, 'Type anything here'); }
In the
OnAfterRenderAsync
method of theIndex
component (Index.razor
):module = await JS.InvokeAsync<IJSObjectReference>( "import", "./Components/Pages/Index.razor.js");
When the app is published, the framework automatically moves the script to the web root. In the preceding example, the script is moved to
bin\Release\{TARGET FRAMEWORK MONIKER}\publish\wwwroot\Components\Pages\Index.razor.js
, where the{TARGET FRAMEWORK MONIKER}
placeholder is the Target Framework Moniker (TFM). No change is required to the script's relative URL in theIndex
component.- The
For scripts provided by a Razor class library (RCL):
_content/{PACKAGE ID}/{PATH}/{PAGE, VIEW, OR COMPONENT}.{EXTENSION}.js
- The
{PACKAGE ID}
placeholder is the RCL's package identifier (or library name for a class library referenced by the app). - The
{PATH}
placeholder is the path to the page, view, or component. If a Razor component is located at the root of the RCL, the path segment isn't included. - The
{PAGE, VIEW, OR COMPONENT}
placeholder is the page, view, or component. - The
{EXTENSION}
placeholder matches the extension of page, view, or component, eitherrazor
orcshtml
.
In the following Blazor app example:
- The RCL's package identifier is
AppJS
. - A module's scripts are loaded for the
Index
component (Index.razor
). - The
Index
component is in thePages
folder of theComponents
folder of the RCL.
var module = await JS.InvokeAsync<IJSObjectReference>("import", "./_content/AppJS/Components/Pages/Index.razor.js");
- The
For more information on RCLs, see Consume ASP.NET Core Razor components from a Razor class library (RCL).
Load a script from an external JavaScript file (.js
)
Place the JavaScript (JS) tags (<script>...</script>
) with a script source (src
) path inside the closing </body>
element after the Blazor script reference:
<body>
...
<script src="{BLAZOR SCRIPT}"></script>
<script src="{SCRIPT PATH AND FILE NAME (.js)}"></script>
</body>
In the preceding example:
- The
{BLAZOR SCRIPT}
placeholder is the Blazor script path and file name. For the location of the script, see ASP.NET Core Blazor project structure. - The
{SCRIPT PATH AND FILE NAME (.js)}
placeholder is the path and script file name underwwwroot
.
In the following example of the preceding <script>
tag, the scripts.js
file is in the wwwroot/js
folder of the app:
<script src="js/scripts.js"></script>
You can also serve scripts directly from the wwwroot
folder if you prefer not to keep all of your scripts in a separate folder under wwwroot
:
<script src="scripts.js"></script>
When the external JS file is supplied by a Razor class library, specify the JS file using its stable static web asset path: ./_content/{PACKAGE ID}/{SCRIPT PATH AND FILE NAME (.js)}
:
- The path segment for the current directory (
./
) is required in order to create the correct static asset path to the JS file. - The
{PACKAGE ID}
placeholder is the library's package ID. The package ID defaults to the project's assembly name if<PackageId>
isn't specified in the project file. - The
{SCRIPT PATH AND FILE NAME (.js)}
placeholder is the path and file name underwwwroot
.
<body>
...
<script src="{BLAZOR SCRIPT}"></script>
<script src="./_content/{PACKAGE ID}/{SCRIPT PATH AND FILE NAME (.js)}"></script>
</body>
In the following example of the preceding <script>
tag:
- The Razor class library has an assembly name of
ComponentLibrary
, and a<PackageId>
isn't specified in the library's project file. - The
scripts.js
file is in the class library'swwwroot
folder.
<script src="./_content/ComponentLibrary/scripts.js"></script>
For more information, see Consume ASP.NET Core Razor components from a Razor class library (RCL).
Inject a script before or after Blazor starts
To ensure scripts load before or after Blazor starts, use a JavaScript initializer. For more information and examples, see ASP.NET Core Blazor startup.
Inject a script after Blazor starts
To inject a script after Blazor starts, chain to the Promise
that results from a manual start of Blazor. For more information and an example, see ASP.NET Core Blazor startup.
JavaScript isolation in JavaScript modules
Blazor enables JavaScript (JS) isolation in standard JavaScript modules (ECMAScript specification).
JS isolation provides the following benefits:
- Imported JS no longer pollutes the global namespace.
- Consumers of a library and components aren't required to import the related JS.
For more information, see Call JavaScript functions from .NET methods in ASP.NET Core Blazor.
Dynamic import with the import()
operator is supported with ASP.NET Core and Blazor:
if ({CONDITION}) import("/additionalModule.js");
In the preceding example, the {CONDITION}
placeholder represents a conditional check to determine if the module should be loaded.
For browser compatibility, see Can I use: JavaScript modules: dynamic import.
Cached JavaScript files
JavaScript (JS) files and other static assets aren't generally cached on clients during development in the Development
environment. During development, static asset requests include the Cache-Control
header with a value of no-cache
or max-age
with a value of zero (0
).
During production in the Production
environment, JS files are usually cached by clients.
To disable client-side caching in browsers, developers usually adopt one of the following approaches:
- Disable caching when the browser's developer tools console is open. Guidance can be found in the developer tools documentation of each browser maintainer:
- Perform a manual browser refresh of any webpage of the Blazor app to reload JS files from the server. ASP.NET Core's HTTP Caching Middleware always honors a valid no-cache
Cache-Control
header sent by a client.
For more information, see:
Size limits on JavaScript interop calls
This section only applies to interactive components in server-side apps. For client-side components, the framework doesn't impose a limit on the size of JavaScript (JS) interop inputs and outputs.
For interactive components in server-side apps, JS interop calls passing data from the client to the server are limited in size by the maximum incoming SignalR message size permitted for hub methods, which is enforced by HubOptions.MaximumReceiveMessageSize (default: 32 KB). JS to .NET SignalR messages larger than MaximumReceiveMessageSize throw an error. The framework doesn't impose a limit on the size of a SignalR message from the hub to a client. For more information on the size limit, error messages, and guidance on dealing with message size limits, see ASP.NET Core Blazor SignalR guidance.
Determine where the app is running
If it's relevant for the app to know where code is running for JS interop calls, use OperatingSystem.IsBrowser to determine if the component is executing in the context of browser on WebAssembly.
ASP.NET Core
Feedback
Submit and view feedback for