ASP.NET கோர் பிளேஸர் சர்வரில் "அழைப்பு டிஸ்பேச்சர் அமைக்கப்படவில்லை" பிழையைத் தீர்ப்பதற்கான ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்பு

Blazor Server பயன்பாடுகளில் JavaScript மற்றும் .NET ஒருங்கிணைப்பைக் கையாளுதல்

ஜாவாஸ்கிரிப்டை.NET செயல்பாடுகளை ஒருங்கிணைப்பது Blazor Server ஐப் பயன்படுத்தும் போது எதிர்பாராத சிக்கல்களை எப்போதாவது ஏற்படுத்தலாம். JavaScript இலிருந்து NET செயல்பாடுகளை அழைக்கும்போது தோன்றும் "அழைப்பு அனுப்புநர் அமைக்கப்படவில்லை" பிழையானது டெவலப்பர்களுக்கு அடிக்கடி ஏற்படும் பிரச்சனையாகும். Blazor கூறுகளுக்கு வெளியே இருந்து static.NET செயல்பாடுகளை அழைக்க முயற்சிக்கும் போது, ​​இந்த பிரச்சனை மிகவும் எரிச்சலூட்டும்.

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

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

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

Blazor சர்வரில் ஜாவாஸ்கிரிப்டைப் புரிந்துகொள்வது

Blazor Server பயன்பாட்டில் JavaScript இலிருந்து a.NET முறையைப் பயன்படுத்துவதில் உள்ள சிக்கல் கொடுக்கப்பட்ட ஸ்கிரிப்ட்களால் தீர்க்கப்படுகிறது. புரோகிராமர்கள் ஜாவாஸ்கிரிப்டைப் பயன்படுத்தி call.NET செயல்பாடுகளைச் செய்ய முயலும்போது, ​​"அழைப்பு அனுப்புபவர் எதுவும் அமைக்கப்படவில்லை" என்ற பிழையைப் பெறும்போது முக்கிய சிக்கல் எழுகிறது. அழைப்பு அனுப்புபவர் சரியாக உள்ளமைக்கப்பட்டுள்ளதா என்பதை Blazor Server கட்டமைப்பு சரிபார்க்கும் வரை JavaScript ஆனது.NET பின்தளத்துடன் தொடர்பு கொள்ள முடியாது என்பதால் இது நிகழ்கிறது. இந்த எடுத்துக்காட்டில்,.NET முறைகள் நிலையான சேவை வகுப்பில் சேமிக்கப்படும் JsHelperService, இது உலகளவில் அவற்றைக் கிடைக்கச் செய்கிறது மற்றும் சிதையக்கூடிய ஒரு குறிப்பிட்ட கூறுக்கு மட்டும் கட்டுப்படுத்தப்படவில்லை.

தி [JSI அழைக்கக்கூடியது] முக்கிய கட்டளையை உருவாக்குவது அவசியம் நெட் method callable from JavaScript. This attribute in the script designates the method JavaScript இலிருந்து அழைக்கக்கூடிய முறை. ஸ்கிரிப்ட்டில் உள்ள இந்த பண்புக்கூறு i>WriteInfo முறையைக் குறிக்கிறது, அதை ஜாவாஸ்கிரிப்ட் அணுகக்கூடியதாக மாற்றுகிறது. இந்தச் செய்தி-பதிவுச் சேவையின் உதவியுடன், JavaScriptஐத் திறந்து வைத்திருக்கும் போது, ​​மையப்படுத்தப்பட்ட பதிவுக்கு.NETஐ எவ்வாறு மேம்படுத்துவது என்பதை நீங்கள் பார்க்கலாம். தி Init இலிருந்து சேவையை அழைக்க முறை பயன்படுத்தப்பட வேண்டும் Program.cs பயன்பாடு தொடங்கும் போது அது உடனடியாகத் தொடங்கப்படும் மற்றும் அகற்றப்படக்கூடிய தனித்தனி கூறுகளைச் சார்ந்து இருக்காது.

எடுத்துக்காட்டின் ஜாவாஸ்கிரிப்ட் பகுதியானது.NET செயல்பாட்டை ஒத்திசைவற்ற முறையில் பயன்படுத்துகிறது window.DotNet.invokeMethodAsync. அழைக்கப்படும் ஒவ்வொரு முறையும் தடுக்காத முறையில் செயலாக்கப்படுவதை இது உறுதிசெய்கிறது, இது a.NET பதிலுக்காகக் காத்திருக்கும் போது மற்ற குறியீடுகளை இடைக்காலத்தில் இயக்க உதவுகிறது. ஸ்கிரிப்ட் மீண்டும் பயன்படுத்தக்கூடிய முறையை உருவாக்குகிறது தகவல் எழுதவும் இதை ஒதுக்குவதன் மூலம் தகவலைப் பதிவு செய்ய நிரலின் எந்தப் பகுதியிலிருந்தும் அழைக்கப்படலாம் window.dotnetLogger பொருள். பிழைத்திருத்தத்திற்கு, ஸ்கிரிப்ட் பயன்படுத்துகிறது a பிழைத்திருத்தி வரி, இது டெவலப்பரை இயக்க நேரத்தை இடைநிறுத்தவும் மாறிகளின் நிலையை ஆராயவும் உதவுகிறது.

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

namespace MyNamespace.Utility
{
    public static class JsHelperService
    {
        static JsHelperService()
        {
            var i = 0; // Constructor breakpoint test
        }
        public static void Init() { /* Ensure initialization in Program.cs */ }
        [JSInvokable("WriteInfo")]
        public static void WriteInfo(string message)
        {
            Logger.Instance.WriteInfo(message);
        }
    }
}

namespace MyNamespace.Utility
{
    public class JsHelperService
    {
        private readonly ILogger _logger;
        public JsHelperService(ILogger<JsHelperService> logger)
        {
            _logger = logger;
        }
        [JSInvokable("WriteInfo")]
        public void WriteInfo(string message)
        {
            _logger.LogInformation(message);
        }
    }
}

// In Program.cs, register the service
builder.Services.AddSingleton<JsHelperService>();

function setupLogging() {
    debugger; // For debugging
    window.dotnetLogger = window.dotnetLogger || {};
    window.dotnetLogger.writeInfo = function (message) {
        window.DotNet.invokeMethodAsync('MyNamespace', 'WriteInfo', message)
        .then(response => console.log('Info logged successfully'))
        .catch(error => console.error('Error logging info:', error));
    };
}

using Xunit;
public class JsHelperServiceTests
{
    private readonly Mock<ILogger<JsHelperService>> _mockLogger;
    private readonly JsHelperService _jsHelperService;
    public JsHelperServiceTests()
    {
        _mockLogger = new Mock<ILogger<JsHelperService>>();
        _jsHelperService = new JsHelperService(_mockLogger.Object);
    }
    [Fact]
    public void WriteInfo_LogsMessage()
    {
        var message = "Test log message";
        _jsHelperService.WriteInfo(message);
        _mockLogger.Verify(logger => logger.LogInformation(message), Times.Once);
    }
}

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

சக்திவாய்ந்த ஆன்லைன் பயன்பாடுகளை உருவாக்க Blazor Serverக்கு, JavaScript மற்றும்.NET ஒருங்கிணைப்பு அவசியம். ஆனால் நிலையான சேவைகளுடன் பணிபுரிய Blazor ஐப் பயன்படுத்துவது சவாலானது, குறிப்பாக JavaScript உடன் ஈடுபடும் போது. JavaScript இலிருந்து அழைக்கும்.NET செயல்பாடுகளில், "அழைப்பு அனுப்புபவர் அமைக்கப்படவில்லை" என்ற பிழை அடிக்கடி நிகழ்கிறது. Blazor's JavaScript Interop, குறுக்கு-சுற்றுச்சூழல் அழைப்புகளைக் கையாளுவதற்கு அழைப்பு அனுப்புபவரைச் சார்ந்தது, பொதுவாக இந்தச் சிக்கலை முறையற்ற அமைவு அல்லது காணாமல் போன உள்ளமைவுகள் காரணமாகக் கொண்டுள்ளது. இத்தகைய தவறுகளைத் தடுக்க, பிளேஸர் எவ்வாறு அதன் டிஸ்பாச்சரை துவக்குகிறது மற்றும் பராமரிக்கிறது என்பதைப் புரிந்துகொள்ள வேண்டும்.

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

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