private void InvokeEngineHelper(string exportName = null, object[] args = null)
        {
            Task <bool> cachedTask = _jsService.TryInvokeFromCacheAsync(ENGINE_HELPERS_RESOURCE_NAME,
                                                                        exportName, args);
            bool success = cachedTask.ConfigureAwait(false).GetAwaiter().GetResult();

            if (!success)
            {
                Type     type     = typeof(NodeJsEngine);
                Assembly assembly = type.Assembly;

                using (Stream resourceStream = assembly.GetManifestResourceStream(ENGINE_HELPERS_RESOURCE_NAME))
                {
                    Task task = _jsService.InvokeFromStreamAsync(resourceStream, ENGINE_HELPERS_RESOURCE_NAME,
                                                                 exportName, args);
                    task.ConfigureAwait(false).GetAwaiter().GetResult();
                }
            }
        }
Esempio n. 2
0
        /// <inheritdoc />
        public virtual async Task <string?> HighlightAsync(string code,
                                                           string languageAlias,
                                                           string classPrefix = "hljs-",
                                                           CancellationToken cancellationToken = default)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException(nameof(HighlightJSService));
            }

            if (code == null)
            {
                throw new ArgumentNullException(nameof(code), Strings.Exception_ParameterCannotBeNull);
            }

            if (string.IsNullOrWhiteSpace(code))
            {
                // Nothing to highlight
                return(code);
            }

            if (!await IsValidLanguageAliasAsync(languageAlias, cancellationToken).ConfigureAwait(false))
            {
                // languageAlias is invalid
                throw new ArgumentException(string.Format(Strings.Exception_InvalidHighlightJSLanguageAlias, languageAlias));
            }

            object[] args = new object[] { code, languageAlias, string.IsNullOrWhiteSpace(classPrefix) ? "" : classPrefix };
            // Invoke from cache
            (bool success, string?result) = await _nodeJSService.TryInvokeFromCacheAsync <string>(_moduleCacheIdentifier, "highlight", args, cancellationToken).ConfigureAwait(false);

            if (success)
            {
                return(result);
            }

            // Invoke from stream since module is not cached
            using Stream moduleStream = _embeddedResourcesService.ReadAsStream(typeof(HighlightJSService).GetTypeInfo().Assembly, BUNDLE_NAME);
            // Invoking from stream is 2+x faster than reading the resource as a string and invoking as string. This is because invoking as string causes almost
            // 1000x more memory to be allocated, resulting in gen 1+ gcs.
            return(await _nodeJSService.InvokeFromStreamAsync <string>(moduleStream, _moduleCacheIdentifier, "highlight", args, cancellationToken).ConfigureAwait(false));
        }
        public Task <T> Invoke <T>(string function, IMemoryOwner <char> code, CancellationToken cancellationToken = default)
        {
            var args = new object[] { code };

            return(_nodeJsService.InvokeFromStreamAsync <T>(
                       () => _embeddedResourcesService.ReadAsStream(GetType().Assembly, BUNDLENAME),
                       MODULE_CACHE_IDENTIFIER,
                       function,
                       args,
                       cancellationToken));
        }