HTML5 கேன்வாஸை மாற்ற,

Jules David

செவ்வாய், 8 அக்டோபர், 2024 ’அன்று’ முற்பகல் 6:24:02

பிளேசரில் HTML5 கேன்வாஸுடன் ஜாவாஸ்கிரிப்டை ஒருங்கிணைக்கிறது

Blazor Server பயன்பாடுகள் C# மற்றும் .NET தொழில்நுட்பங்களைப் பயன்படுத்தி சக்திவாய்ந்த வலைப் பயன்பாடுகளை உருவாக்குவதற்கான நெகிழ்வுத்தன்மையை டெவலப்பர்களுக்கு வழங்குகிறது. இருப்பினும், ஜாவாஸ்கிரிப்டை மேம்படுத்துவது, குறிப்பாக HTML5 கேன்வாஸ் உறுப்பைக் கையாளுதல் போன்ற பணிகளுக்கு அவசியமான சூழ்நிலைகள் உள்ளன. அத்தகைய ஒரு காட்சியானது பிளேஸர் கூறு வழியாக அனுப்பப்பட்ட தரவுகளின் அடிப்படையில் கேன்வாஸில் மாறும் வகையில் வரைவதை உள்ளடக்கியது.

இந்த குறிப்பிட்ட அமைப்பில், உங்கள் Blazor Razor பக்கத்தில் ஒரு லூப் இருக்கலாம், அங்கு தனிப்பட்ட HTML கேன்வாஸ் கூறுகளை உருவாக்க தரவுகளின் பட்டியல் பயன்படுத்தப்படும். ஒவ்வொரு கேன்வாஸுக்கும், படங்கள் அல்லது வடிவங்களை வழங்க தனிப்பயன் JavaScript செயல்பாட்டை அழைக்க வேண்டும். சி# மற்றும் ஜாவாஸ்கிரிப்ட்டின் இந்த கலவையானது ஒரு தனித்துவமான சவாலை வழங்குகிறது ஆனால் சிறந்த பல்துறை திறனை வழங்குகிறது.

உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டை நீங்கள் தனித்த HTML திட்டங்களில் வெற்றிகரமாகச் சோதித்திருக்கலாம், அதை Blazor இல் ஒருங்கிணைக்க, குறிப்பாக Razor HTML பிரிவில் இருந்து அழைக்க, வேறுபட்ட அணுகுமுறை தேவைப்படுகிறது. இங்குதான் Blazor இன் ஜாவாஸ்கிரிப்ட் இன்டெராப் செயல்பாட்டுக்கு வருகிறது, குறிப்பாக `IJSRuntime` சேவையைப் பயன்படுத்துவதன் மூலம்.

இந்த வழிகாட்டியில், Blazor சர்வர் திட்டத்தின் HTML பிரிவில் இருந்து கேன்வாஸைக் கையாள உங்கள் தனிப்பயன் JavaScript செயல்பாட்டை எவ்வாறு அழைக்கலாம் என்பதை நாங்கள் ஆராய்வோம். Blazor மற்றும் JavaScript இடையே சீரான ஒருங்கிணைப்பை உறுதிசெய்ய, செயல்முறையை படிப்படியாக உடைப்போம்.

கட்டளை	பயன்பாட்டின் உதாரணம்
@inject	தி @ஊசி ஒரு சேவையை புகுத்துவதற்கு உத்தரவு பயன்படுத்தப்படுகிறது (எ.கா IJSR இயக்க நேரம்) ஒரு பிளேஸர் பாகமாக. இது Blazor பயன்பாட்டில் C# இலிருந்து JavaScript செயல்பாடுகளை அழைக்க அனுமதிக்கிறது. எடுத்துக்காட்டாக, @inject IJSRuntime JSRuntime JavaScript இயக்க நேர சேவையை செலுத்துகிறது.
InvokeVoidAsync	இந்த முறை ஒரு பகுதியாகும் IJSR இயக்க நேரம் மற்றும் திரும்ப மதிப்பை எதிர்பார்க்காமல் C# இலிருந்து JavaScript செயல்பாட்டை செயல்படுத்த பயன்படுகிறது. உதாரணமாக, JSRuntime.InvokeVoidAsync("drawImage", canvasId, data); ஜாவாஸ்கிரிப்ட் செயல்பாட்டை அழைக்கிறது வரைதல் படம் கேன்வாஸைக் கையாள.
OnAfterRenderAsync	பிளேஸரில் உள்ள இந்த லைஃப்சைக்கிள் முறையானது கூறுகளை வழங்கிய பிறகு செயல்படுத்தப்படுகிறது. பக்கத்தை ரெண்டரிங் செய்த பிறகு ஜாவாஸ்கிரிப்ட் தொகுதியை ஏற்றுவது போன்ற பக்கமும் அதன் கூறுகளும் தயாரானவுடன் ஜாவாஸ்கிரிப்ட் குறியீட்டை இயக்க இது பெரும்பாலும் பயன்படுத்தப்படுகிறது. எடுத்துக்காட்டு: பாதுகாக்கப்பட்ட ஓவர்ரைடு ஒத்திசைவு பணி ஆன்அப்டர்ரெண்டர்அசின்க்(பூல் ஃபர்ஸ்ட்ரெண்டர்).
IJSObjectReference	தி IJSObject குறிப்பு Blazor இல் JavaScript தொகுதிகளை இறக்குமதி செய்யும் போது இடைமுகம் பயன்படுத்தப்படுகிறது. இது வெளிப்புற JS கோப்புகளைக் குறிப்பிடுவதன் மூலம் மட்டு ஜாவாஸ்கிரிப்ட் தொடர்புகளை செயல்படுத்துகிறது. எடுத்துக்காட்டாக, IJSObjectReference jsModule = காத்திருக்கவும் JSRuntime.InvokeAsync("இறக்குமதி", "./js/MyJavaScript.js"); JS தொகுதியை இறக்குமதி செய்கிறது.
Verifiable	This is a method from the Moq library used in unit testing. It marks an expectation as verifiable, ensuring that the call to a mocked method (such as a JavaScript interop function) was made during the test. Example: jsInteropMock.Setup(x =>இது யூனிட் டெஸ்டிங்கில் பயன்படுத்தப்படும் Moq நூலகத்தின் ஒரு முறையாகும். சோதனையின் போது கேலி செய்யப்பட்ட முறைக்கான அழைப்பு (ஜாவாஸ்கிரிப்ட் இன்டெராப் செயல்பாடு போன்றவை) செய்யப்பட்டதை உறுதிசெய்து, இது ஒரு எதிர்பார்ப்பை சரிபார்க்கக்கூடியதாகக் குறிக்கிறது. எடுத்துக்காட்டு: jsInteropMock.Setup(x => x.InvokeAsync("வரைய படம்", இது.IsAny())).சரிபார்க்கக்கூடிய();.
await	இது ஒரு ஒத்திசைவற்ற நிரலாக்க கட்டளையாகும், இது ஜாவாஸ்கிரிப்ட் இன்டராப் அழைப்பு போன்ற ஒத்திசைவு செயல்பாட்டின் முடிவுக்காக காத்திருக்கிறது. எடுத்துக்காட்டாக, JSRuntime காத்திருங்கள்.InvokeVoidAsync("drawImage", canvasId, data); செயல்படுத்துவதைத் தொடர்வதற்கு முன் செயல்பாடு நிறைவடைவதை உறுதி செய்கிறது.
@code	தி @குறியீடு பிளேசரில் உள்ள பிளாக் C# குறியீட்டை ரேஸர் பாகத்தில் இன்லைனில் எழுத அனுமதிக்கிறது. இங்குதான் ஜாவாஸ்கிரிப்ட் செயல்பாடுகளை செயல்படுத்துதல் அல்லது கூறு முறைகளை வரையறுத்தல் போன்ற தர்க்கம் வைக்கப்படுகிறது. எடுத்துக்காட்டு: @குறியீடு {பொது வெற்றிடமான DrawImageOnCanvas() { ... } }.
It.IsAny	போலி அமைவின் போது குறிப்பிட்ட வகையின் எந்த மதிப்பையும் பொருத்த யூனிட் சோதனையில் இது பயன்படுத்தப்படுகிறது. டைனமிக் டேட்டாவை ஏற்றுக்கொள்ளும் இண்டராப் அழைப்புகளை கேலி செய்வதில் இது மிகவும் பயனுள்ளதாக இருக்கும். எடுத்துக்காட்டு: It.IsAny() பொருள்களின் எந்த வரிசையையும் அனுப்ப அனுமதிக்கிறது.

கேன்வாஸ் கையாளுதலுக்கான பிளேஸர் மற்றும் ஜாவாஸ்கிரிப்ட் இன்டெராப் பற்றி விளக்குகிறது

முதல் ஸ்கிரிப்ட் உதாரணம் எவ்வாறு அந்நியப்படுத்துவது என்பதை விளக்குகிறது IJSR இயக்க நேரம் Blazor கூறுக்குள் இருந்து JavaScript செயல்பாடுகளை செயல்படுத்த. தி @ஊசி கட்டளை ஊசி பயன்படுத்தப்படுகிறது IJSR இயக்க நேரம் சேவை, இது Blazor மற்றும் JavaScript இடையே தொடர்பு கொள்ள உதவுகிறது. போன்ற HTML கூறுகளை நீங்கள் கையாள வேண்டியிருக்கும் போது இது அவசியம் HTML5 கேன்வாஸ் C# இலிருந்து. இந்த எடுத்துக்காட்டில், ஒரு லூப் தரவுகளின் பட்டியலின் மூலம் செல்கிறது, மேலும் பட்டியலில் உள்ள ஒவ்வொரு உருப்படிக்கும், ஒரு கேன்வாஸ் உறுப்பு மாறும் வகையில் உருவாக்கப்படும். ஒரு பொத்தானைக் கிளிக் செய்வதன் மூலம், ஜாவாஸ்கிரிப்ட் செயல்பாடு வரைதல் படம் அழைக்கப்படுகிறது, கேன்வாஸின் ஐடி மற்றும் தொடர்புடைய தரவை அனுப்புகிறது.

இந்த அணுகுமுறையின் முக்கிய அம்சம் பயன்பாடு ஆகும் InvokeVoidAsync, திரும்பும் மதிப்பை எதிர்பார்க்காமல் ஜாவாஸ்கிரிப்ட் செயல்பாடுகளை அழைக்க C# ஐ அனுமதிக்கும் ஒரு முறை. கேன்வாஸில் ஒரு படத்தை வரைவது போன்ற ஒரு செயலைச் செய்ய விரும்பும்போது இது முக்கியமானது, மேலும் JavaScript இலிருந்து பதில் தேவையில்லை. மற்றொரு குறிப்பிடத்தக்க பகுதி OnAfterRenderAsync Blazor இல் லைஃப்சைக்கிள் முறை, கூறு முழுவதுமாக ரெண்டர் செய்யப்பட்ட பிறகு ஜாவாஸ்கிரிப்ட் செயல்பாடு அழைக்கப்படுவதை உறுதி செய்கிறது. கேன்வாஸ் போன்ற DOM உறுப்புகளை கையாளும் போது இது மிகவும் முக்கியமானது, ஏனெனில் கேன்வாஸை மிக விரைவாக அணுக முயற்சிப்பது பிழைகளை ஏற்படுத்தலாம்.

இரண்டாவது ஸ்கிரிப்ட் எடுத்துக்காட்டில், மிகவும் மட்டுப்படுத்தப்பட்ட அணுகுமுறையைப் பயன்படுத்தி அறிமுகப்படுத்தப்பட்டது IJSObject குறிப்பு. ஜாவாஸ்கிரிப்ட் குறியீட்டை ஒரு தொகுதியாக ஏற்ற இது உங்களை அனுமதிக்கிறது, இது பல கூறுகளில் மீண்டும் பயன்படுத்தப்படலாம். தொகுதி ஒரு முறை ஏற்றப்படுகிறது, பின்னர் அதில் உள்ள செயல்பாடுகள் தேவைப்படும்போது அழைக்கப்படும். இந்த முறை குறியீட்டின் பராமரிப்பை மேம்படுத்துகிறது மற்றும் பெரிய ஜாவாஸ்கிரிப்ட் கோட்பேஸ்களை நிர்வகிப்பதை எளிதாக்குகிறது. ஜாவாஸ்கிரிப்ட் தொகுதியை ஒருமுறை மட்டும் இறக்குமதி செய்வதன் மூலம், உங்கள் பயன்பாட்டின் செயல்திறன் மேம்படுத்தப்படும், மேலும் தேவையில்லாமல் ஸ்கிரிப்ட்களை மீண்டும் ஏற்றுவதைத் தவிர்க்கிறீர்கள்.

இறுதியாக, அலகு சோதனை ஸ்கிரிப்ட் பயன்படுத்துகிறது Moq ஜாவாஸ்கிரிப்ட் இண்டராப் அழைப்புகள் சரியாகச் செயல்படுவதை உறுதிசெய்ய நூலகம். தி சரிபார்க்கக்கூடியது எதிர்பார்க்கப்படும் அழைப்புகளைக் குறிக்க இந்த முறை பயன்படுத்தப்படுகிறது InvokeAsync சரிபார்க்கக்கூடியது, அதாவது சோதனைகளின் போது, interop செயல்பாடு சரியான அளவுருக்கள் மூலம் அழைக்கப்பட்டதா என்பதை நீங்கள் சரிபார்க்கலாம். இந்த முறை Blazor மற்றும் JavaScript இடையேயான ஒருங்கிணைப்பு உறுதியானது என்பதை உறுதிசெய்கிறது, மேலும் இது சோதனையின் போது interop அழைப்புகளின் சரியான தன்மையை சரிபார்ப்பதன் மூலம் உங்கள் திட்டத்திற்கு கூடுதல் நம்பகத்தன்மையை சேர்க்கிறது.

தீர்வு 1: HTML5 கேன்வாஸுடன் ஜாவாஸ்கிரிப்ட் இண்டராப்பிற்கான IJSRuntime ஐப் பயன்படுத்துதல்

HTML5 கேன்வாஸைக் கையாளும் ஜாவாஸ்கிரிப்ட் செயல்பாட்டை அழைக்க, பிளேசரில் IJSRuntime சேவையை எவ்வாறு பயன்படுத்துவது என்பதை இந்த அணுகுமுறை விளக்குகிறது.

// MyPage.razor
@page "/mypage"
@inject IJSRuntime JSRuntime
@code {
    private async Task DrawImageOnCanvas(MyData data)
    {
        await JSRuntime.InvokeVoidAsync("drawImage", data.Id, data);
    }
}

<div>@foreach (var data in ListOfMyData) {
    <div><canvas id="@data.Id" class="myDataImage"></canvas></div>
    <button @onclick="() => DrawImageOnCanvas(data)">Draw Image</button>
}</div>

தீர்வு 2: JavaScript தொகுதியை ஏற்ற JSObjectReference ஐப் பயன்படுத்துதல்

இந்தத் தீர்வு ஜாவாஸ்கிரிப்ட் கோப்பை ஒரு தொகுதியாக ஏற்றுவதன் மூலம் ஒரு மட்டு அணுகுமுறையை எடுக்கிறது, இது மீண்டும் பயன்படுத்தக்கூடியது மற்றும் தூய்மையானது.

// MyPage.razor
@page "/mypage"
@inject IJSRuntime JSRuntime
@code {
    private IJSObjectReference _jsModule;
    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender)
        {
            _jsModule = await JSRuntime.InvokeAsync<IJSObjectReference>("import", "./js/MyJavaScript.js");
        }
    }
    private async Task DrawImageOnCanvas(MyData data)
    {
        await _jsModule.InvokeVoidAsync("drawImage", data.Id, data);
    }
}

<div>@foreach (var data in ListOfMyData) {
    <div><canvas id="@data.Id" class="myDataImage"></canvas></div>
    <button @onclick="() => DrawImageOnCanvas(data)">Draw Image</button>
}</div>

தீர்வு 3: HTML5 கேன்வாஸுடன் ஜாவாஸ்கிரிப்ட் இண்டெராப்பைச் சோதிக்கும் அலகு

கேன்வாஸ் கையாளுதல் சரியாக வேலை செய்வதை உறுதிசெய்து, பிளேஸர் கூறுகளுக்கான ப்யூனிட்டைப் பயன்படுத்தி யூனிட் சோதனையைச் சேர்க்கிறது.

// TestComponent.razor.cs
@page "/testpage"
@inject IJSRuntime JSRuntime
@code {
    public void TestDrawImage()
    {
        var jsInteropMock = new Mock<IJSRuntime>();
        jsInteropMock.Setup(x => x.InvokeAsync<Void>("drawImage", It.IsAny<object[]>())).Verifiable();
        jsInteropMock.Verify();
    }
}

Blazor இல் டைனமிக் கேன்வாஸ் கையாளுதலுக்கான ஜாவாஸ்கிரிப்ட் இன்டராப் ஆய்வு

Blazor இல், தனிப்பயன் JavaScript செயல்பாடுகளை அழைக்கும் திறன், டைனமிக் முன்-இறுதி கையாளுதலுக்கான சக்திவாய்ந்த விருப்பங்களைத் திறக்கிறது, குறிப்பாக இது போன்ற வரைகலை கூறுகளுடன் பணிபுரியும் போது HTML5 கேன்வாஸ். இந்தச் செயல்பாட்டின் ஒரு முக்கிய அம்சம் இதுவரை கவனிக்கப்படாதது, Blazor இன் சர்வர்-சைட் கட்டமைப்பிற்குள் ஒத்திசைவற்ற ஜாவாஸ்கிரிப்ட் அழைப்புகளைப் பயன்படுத்துவதாகும். Blazor சர்வரில் செயல்படுவதால், கிளையன்ட் மற்றும் சர்வர் இடையேயான தொடர்பு சிக்னல்ஆர் வழியாக கையாளப்படுகிறது, அதாவது ரேஸர் பக்கத்திலிருந்து ஜாவாஸ்கிரிப்ட் செயல்பாட்டை நீங்கள் அழைக்கும் போது, தொடர்பு சிறிது தாமதமாகும். இந்த ஒத்திசைவற்ற செயல்பாடுகளை எவ்வாறு கையாள்வது என்பதைப் புரிந்துகொள்வது, கேன்வாஸ் கையாளுதல் சீராக நடப்பதை உறுதி செய்கிறது.

பக்கத்தில் பல கேன்வாஸ் கூறுகள் இருக்கும்போது ஜாவாஸ்கிரிப்ட் மற்றும் சி# தொடர்பு கொள்ளும் விதத்தை மேம்படுத்துவது மற்றொரு முக்கியமான காரணியாகும். நீங்கள் ஒரு பட்டியலைப் பார்க்கும்போது, ஒவ்வொரு பொருளுக்கும் அதன் சொந்தம் இருக்கும் கேன்வாஸ் உறுப்பு, ஒவ்வொரு கேன்வாஸும் தொடர்புடைய ஜாவாஸ்கிரிப்ட் செயல்பாட்டிலிருந்து சரியான வரைதல் வழிமுறைகளைப் பெறுவதை உறுதி செய்வதே சவால். ஒவ்வொரு கேன்வாஸுக்கும் ஒரு தனிப்பட்ட அடையாளங்காட்டி இருப்பதை உறுதி செய்வதன் மூலம் இதை திறமையாக கையாள முடியும், இது interop அழைப்பில் ஒரு அளவுருவாக அனுப்பப்படுகிறது. ஜாவாஸ்கிரிப்டில் சரியான பிழை கையாளுதல் மற்றும் சரிபார்த்தல் ஆகியவை பல கேன்வாஸ்களை செயலாக்கும்போது முக்கியமானதாகிறது.

கடைசியாக, Blazor இல் ஜாவாஸ்கிரிப்ட் interop உடன் கையாளும் போது செயல்திறன் பரிசீலனைகள் குறிப்பிடத்தக்கவை. பெரும்பாலான சந்தர்ப்பங்களில் சிறிய ஸ்கிரிப்டுகள் நன்றாக வேலை செய்யும் போது, சிக்கலான வடிவங்கள் அல்லது படங்களை வழங்குவது போன்ற கனமான கேன்வாஸ் செயல்பாடுகள் மேம்படுத்தப்படாவிட்டால் செயல்திறன் தடைகளை ஏற்படுத்தும். கேன்வாஸின் அளவைக் கட்டுப்படுத்துதல், ஆஃப்-ஸ்கிரீன் கேன்வாஸ்களைப் பயன்படுத்துதல் அல்லது தொகுதி செயலாக்க வரைகலை மாற்றங்கள் போன்ற நுட்பங்கள் ரெண்டரிங் வேகத்தை மேம்படுத்த உதவும். இந்த மேம்படுத்தல் உத்திகளைப் புரிந்துகொள்வது, சிக்கலான முன்-இறுதி ரெண்டரிங் பணிகளைக் கையாளும் போது, உங்கள் Blazor ஆப்ஸ் தொடர்ந்து செயல்படுவதை உறுதி செய்யும்.

Blazor இல் JavaScript Interop பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்

Blazor இலிருந்து JavaScriptக்கு தரவை எவ்வாறு அனுப்புவது?
நீங்கள் பயன்படுத்தலாம் JSRuntime.InvokeVoidAsync உங்கள் Blazor பாகத்திலிருந்து ஒரு JavaScript செயல்பாட்டிற்கு தரவை அனுப்ப.
ஜாவாஸ்கிரிப்ட் உடன் தொடர்பு கொள்ளும்போது பிளேசரில் ஒத்திசைவு அழைப்புகளை எவ்வாறு கையாள்வது?
பிளேசர் வழங்குகிறது async போன்ற முறைகள் InvokeVoidAsync ஒத்திசைவற்ற ஜாவாஸ்கிரிப்ட் அழைப்புகளைச் செய்ய.
ஒரு வளையத்தில் பல கேன்வாஸ் கூறுகளை நிர்வகிக்க சிறந்த வழி எது?
ஒவ்வொரு கேன்வாஸ் உறுப்புக்கும் ஒரு தனித்தன்மை இருப்பதை உறுதிசெய்யவும் id, மற்றும் அழைக்கும் போது இதை ஒரு அளவுருவாக அனுப்பவும் drawImage செயல்பாடு.
நான் Blazor உடன் வெளிப்புற JavaScript நூலகங்களைப் பயன்படுத்தலாமா?
ஆம், நீங்கள் வெளிப்புற நூலகங்களைப் பயன்படுத்தி இறக்குமதி செய்யலாம் IJSObjectReference உங்கள் Blazor திட்டத்தில் தொகுதிகளாக அவற்றை ஏற்றவும்.
பங்கு என்ன IJSObjectReference பிளேசரில்?
இது Blazor ஐ JavaScript மாட்யூல்களுடன் ஒரு மட்டு, மீண்டும் பயன்படுத்தக்கூடிய வகையில் தொடர்பு கொள்ள அனுமதிக்கிறது, செயல்திறன் மற்றும் குறியீட்டு அமைப்பை மேம்படுத்துகிறது.

பிளேசர் மற்றும் ஜாவாஸ்கிரிப்ட் இன்டெராப் பற்றிய இறுதி எண்ணங்கள்

ஜாவாஸ்கிரிப்டை பிளேஸர் சர்வர் திட்டத்தில் ஒருங்கிணைப்பது, குறிப்பாக HTML5 கேன்வாஸ் போன்ற உறுப்புகளுக்கு, முன்-இறுதிச் செயல்பாட்டை கணிசமாக மேம்படுத்தும். IJSRuntime ஐப் பயன்படுத்துவதன் மூலம், C# மற்றும் JavaScript இடையே தடையற்ற தொடர்பை Blazor அனுமதிக்கிறது, இது கிராபிக்ஸ் டைனமிக் ரெண்டரிங்கை செயல்படுத்துகிறது.

நீங்கள் பல கேன்வாஸ் கூறுகளைக் கையாளுகிறீர்களோ அல்லது செயல்திறனை மேம்படுத்துகிறீர்களோ, ஜாவாஸ்கிரிப்ட் செயல்பாடுகளை எவ்வாறு திறம்பட அழைப்பது என்பதைப் புரிந்துகொள்வது வலுவான வலை பயன்பாடுகளை உருவாக்குவதற்கு முக்கியமாகும். கோடிட்டுக் காட்டப்பட்டுள்ள படிகள் உங்கள் Blazor திட்டங்களுக்கு மென்மையான ஒருங்கிணைப்பையும் சிறந்த செயல்திறனையும் உறுதி செய்கின்றன.

Blazor இல் ஜாவாஸ்கிரிப்ட் Interop க்கான குறிப்புகள் மற்றும் ஆதாரங்கள்

அதிகாரப்பூர்வ ஆவணங்கள் மற்றும் Blazor இல் ஜாவாஸ்கிரிப்ட் இன்டெராப் பற்றிய ஆழமான புரிதலுக்கு, பார்வையிடவும் ASP.NET கோர் பிளேஸர் ஜாவாஸ்கிரிப்ட் இயங்கக்கூடிய வழிகாட்டி .
இந்த பயனுள்ள கட்டுரையிலிருந்து JavaScript மூலம் HTML5 கேன்வாஸ் கூறுகளை நிர்வகிப்பது பற்றி மேலும் அறிக: MDN Web Docs - Canvas API .
Blazor இல் JavaScript இன்டராப் சோதனைக்கு பயன்படுத்தப்படும் சோதனை நூலகமான Moq க்கான முழு ஆவணங்களையும் ஆராயுங்கள்: Moq விரைவு தொடக்கம் .

HTML5 கேன்வாஸை மாற்ற, பிளேஸர் சர்வர் பயன்பாட்டில் தனிப்பயன் ஜாவாஸ்கிரிப்ட் செயல்பாடுகளைப் பயன்படுத்துதல்