JavaScript Interop in Blazor

Introduction

In this article, we will learn about JavaScript Interop in Blazor. We will understand what JavaScript Interop is and how we can implement it in Blazor with the help of a sample application.

We will be using Visual Studio code for our demo.

What is JavaScript Interop?

Blazor uses JavaScript to bootstrap the .NET runtime. It is capable to use any JS library. C# code can call a JS function/API and JS code can call any C# methods. This property of calling a JS method from C# code and vice versa is referred as JavaScript Interop. Blazor uses JavaScript Interop to handle DOM manipulation and browser API calls.

JavaScript Interop is the feature provided by WebAssembly. Since Blazor runs on Mono and mono is compiled to WebAssembly. Hence, Blazor can also implement this feature.

Prerequisites

Install the .NET Core 2.1 or above SDK from here.
Install visual Studio Code from here.

Source Code

The source code has been updated to .NET Core 3.2 Preview-1. Get the source code from Github.

Creating the Blazor application

We will create a Blazor application using windows PowerShell.

Step 1:

First, we will install the Blazor framework templates in our machine,

Open the folder you want to create your project. Open Windows PowerShell by doing shift + right click >> Open PowerShell window Here.

Type in the following command

dotnet new -i Microsoft.AspNetCore.Blazor.Templates

Refer to the image below:

Step 2:

Type in the following command to create our Blazor application.

dotnet new blazor -o BlazorJSDemo

This will create a Blazor application with name BlazorJSDemo. Refer to the image below.

Adding Razor Page to our application

Open the BlazorJSDemo app using VS code. You can observe the folder structure in Solution Explorer, as shown in the below image.

We will add our Razor page in Pages folder.

Create a new file by right clicking on Pages folder and select New File. Name the file as JSDemo.cshtml. This file will contain HTML code to handle the UI of our application.

Similarly, add one more file JSDemo.cshtml.cs. This file will contain the C# code to handle our business logic.

Now our Pages folder will have the following structure.

Calling a JavaScript function from C#

First, we will write our JavaScript functions in index.html file. Open wwwroot/index.html file and put in the following code.

<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width">
    <title>BlazorJSDemo</title>
    <base href="/" />
    <link href="css/bootstrap/bootstrap.min.css" rel="stylesheet" />
    <link href="css/site.css" rel="stylesheet" />

    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>

</head>

<body>
    <app>Loading...</app>

    <script src="_framework/blazor.webassembly.js"></script>

    <script>
        function JSMethod() {
            $("#demop").text("JavaScript Method invoked");
        }
    </script>

</body>

</html>

Here we have included the CDN reference to JQuery library inside <head> section so that we can handle the DOM manipulation.

Inside the <body> section, we have defined our JS function. The function name is JSMethod and it is not accepting any arguments. When triggered it will set the text of a <p> tag having id “demop” to “JavaScript Method invoked”.

Important Note

Do not write your JS code in .cshtml file. This is not allowed in Blazor and the compiler will throw an error. Always put your JS code in wwwroot/index.html file.
Always add your custom <script> tag after “<script src=”_framework/blazor.webassembly.js”></script>” in the <body> section of index.html file. This is to ensure that your custom script will execute after loading of “blazor.webassembly.js” script.

Open JSDemo.cshtml.cs and put in the following code:

using Microsoft.AspNetCore.Blazor.Components;
using Microsoft.JSInterop;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace BlazorJSDemo.Pages
{
    public class JSDemoModel : BlazorComponent
    {
        protected static string message { get; set; }

        protected void CallJSMethod()
        {
            JSRuntime.Current.InvokeAsync<bool>("JSMethod");
        }
    }
}

The method CallJSMethod will call our JS function “JSMethod” by using “JSRuntime.Current.InvokeAsync” method. This method can take two parameters – the JS function name and any parameter that needed to be supplied to the JS function. In this case, we are not passing any parameter to JS function.

Open JSDemo.cshtml and put in the following code:

@page "/demo"
@using BlazorJSDemo.Pages

@inherits JSDemoModel  

<h1>JavaScript Interop Demo</h1>

<hr />

<button class="btn btn-primary" >
Here we have defined the route of the page at the top. So, in this application, if we append “/demo” to base URL then we will be redirected to this page. We are also inheriting JSDemoModel class, which is defined in JSDemo.cshtml.cs file. This will allow us to use the methods defined in JSDemoModel class.
 After this, we have defined a button. This button will invoke “CallJSMethod” method when clicked. The <p> element with id “demop” is also defined and its value will be set by the JS function “JSMethod”.
 Calling a C#/.NET method from JavaScript
 Now we will define our JS Method in wwwroot/index.html file, which will call our C# method in JSDemo.cshtml.cs file.
 The syntax of calling a C# method from JavaScript is as follow :
 DotNet.invokeMethodAsync('C# method assembly name', 'C# Method Name');
Therefore, we will follow the same method calling syntax. Open wwwroot/index.html file and add the following script section to it.
<script>
  function CSMethod() {
    DotNet.invokeMethodAsync('BlazorJSDemo', 'CSCallBackMethod');
  }
</script>
Here we are defining a JS function “CSMethod”. This function will have a call back to our C# method “CSCallBackMethod” which is defined in JSDemoModel class.
To invoke a C#/.NET method from JavaScript the target .NET method must meet the following criterias:
 The method needs to be Static.
 It must be Non-generic.
 The method should have no overloads.
 It has concrete JSON serializable parameter types.
 It must be decorated with [JSInvokable] attribute
Open JSDemo.cshtml.cs file and add the following code inside JSDemoModel class.
protected static string message { get; set; }

[JSInvokable]
public static void CSCallBackMethod()
{
  message = "C# Method invoked";
}

protected void CallCSMethod()
{
  JSRuntime.Current.InvokeAsync<bool>("CSMethod");
}
Here we have defined two methods:
 CallCSMethod :- This will call our JS function “CSMethod”
 CSCallBackMethod: – This is a static method and it will be invoked from JavaScript function “CSMethod”. Hence it is decorated with[JSInvokable] attribute. This method will set the value of a string variable message, which will be displayed on the UI.
Open JSDemo.cshtml file and add the following code to it.
 <button class="btn btn-primary" >Here we have defined a button which will call “CallCSMethod” method on the “onclick” event. The value of variable message is set on the button click.
Adding Link to Navigation menu
Open \BlazorJSDemo\Shared\NavMenu.cshtml page and put the following code into it. This will include a link to our JSDemo.cshtml page in the navigation menu.
 <div class="top-row pl-4 navbar navbar-dark">
<a class="navbar-brand" href="">BlazorJSDemo</a>
<button class="navbar-toggler" >Execution demo
Navigate to View >> Integrated Terminal to open the terminal window.
Type the command dotnet run to start the application. Refer to the image below:
You can observe that the application is listening on http://localhost:5000. Open any browser on your machine and navigate to this URL. You can see the application home page. Click on the “JS Demo” link in the navigation menu to open JSdemo view. Notice the URL has “/demo” appended to it.
Click on the buttons to invoke JS functions and C# method.
Refer to the GIF image below.
Conclusion
We have learned about JavaScript Interop. We have also created a sample application to demonstrate how JavaScript Interop works with Blazor framework.
Get my book Blazor Quick Start Guide to learn more about Blazor.
Please get the source code from Github and play around to get a better understanding.
You can also read this article at C# Corner
See Also
 ASP.NET Core – Getting Started With Blazor
 ASP.NET Core – CRUD Using Blazor And Entity Framework Core
 Creating a SPA Using Razor Pages With Blazor
 Cascading DropDownList In Blazor Using EF Core
 Deploying A Blazor Application On IIS

Ankit Sharma

Next ASP.NET Core - Expense Manager Using EF Core and Highcharts »

Previous « Creating a SPA Using Razor Pages With Blazor

View Comments

Mohammad says:
April 18, 2019 at 8:17 pm
nice article,
Inside Visual Studio 2019 there are to different blazor templates to choose from. What the difference, and when to use which?
- Ankit Sharma says:
  April 18, 2019 at 11:01 pm
  Soon I will publish new articles on using Blazor with VS 2019 and .NET Core 3.0