Exposing Electron errors and error conditions to DotNet #769

New Issue

claunia · 2026-01-29T16:48:09Z

claunia commented

2026-01-29 16:48:09 +00:00

Originally created by @danatcofo on GitHub (Feb 24, 2022).

Originally assigned to: @GregorBiswanger on GitHub.

I've developed some of this locally to validate the ideas but feel like this proposal has some large unknowns that should be discussed prior to adoption or implementation thus... please tear this apart with me.

One of the things that creates a little bit of a blocker for me as a dotnet developer using Electron.NET is that errors that occur in the electron side of Electron.NET are effectively swallowed. This lack of visibility leads to a lot of time spent diagnosing where an issue occurred (Electron or dotnet) even before figuring out why an issue occurred. To promote visibility of errors in electron I propose the following:

For the case where an error occurs and the dotnet side of code is expecting a response but will not receive one:
return a pre-formatted string with the exception information as the content that the dotnet handler can properly parse and throw a .net exception for.
For the case where an error occurs and the dotnet side of code is not expecting a response:
Create a channel to except exceptions from the js into the dotnet code. This would be a generic channel to accept the messages from any location we devise.

Electron Implementation

On the electron side I propose the addition of the following:

postError.ts

import { Socket } from 'net';
let electronSocket: Socket;
export = (socket:Socket):(message:any, channel: string) => void => {
    electronSocket = socket;    
    return (message: any, channel: string):void => {
        let e: Error;
        if (message instanceof Error) {
            e = message;
        }
        else {
            try {
                throw new Error(message);
            }
            catch (error) {
                e = error;
            }
        }
        var errorMessage = `ElectronNETError: ${e.name}: ${e.message}${(e.stack ? `\n--stacktrace--\n${e.stack}` : '')}`
        electronSocket.emit(channel || 'unhandled-electronnet-error', errorMessage);
    };
}

How this would be consumed in the electron side.

// from browserWindows.ts
export = (socket: Socket, app: Electron.App) => {
    electronSocket = socket;
    const postError = require('./postError')(socket);
...
    // dotnet is expecting a response here
    socket.on('browserWindowHasShadow', (id) => {
        const w = getWindowById(id);
        const channel = 'browserWindow-hasShadow-completed';
        if (w) {
            const hasShadow = w.hasShadow();
            electronSocket.emit(channel, hasShadow);
        }
        else {
            postError(`window with id ${id} was not found`, channel);
        }
    });

    // dotnet is not expecting a response   
    socket.on('browserWindowBlur', (id) => {
        const w = getWindowById(id);
        if (w) {
            w.blur();
        }
        else {
            postError(`window with id ${id} was not found`);
        }
    });

    // alternatively we could do
    socket.on('browserWindowBlur', (id) => {
       try {
          getWindowById(id).blur();
       } catch (e) {
          postError(e);
       }
    });
...
}

DotNet Implementation

On the dotnet side we would have a capture class

using System;
using System.Threading.Tasks;

namespace ElectronNET.API
{
    /// <summary></summary>
    public static class ErrorCapture
    {
        private class JsError
        {
            public string Type { get; set; }
            public string Message { get; set; }
            public string StackTrace { get; set; }
        }

        private static object Extract(object value)
        {
            if (value is string s && s.StartsWith("ElectronNETError: "))
            {
                var parts = s.Substring(17).Split("\n--stacktrace--\n");
                var typeSplit = parts[0].IndexOf(':');
                var type = parts[0].Substring(0, typeSplit);
                var message = parts[0].Substring(typeSplit + 1);
                var stackTrace = parts.Length > 1 ? parts[parts.Length - 1] : string.Empty;
                return new JsError
                {
                    Type = type,
                    Message = message,
                    StackTrace = stackTrace,
                };
            }

            return value;
        }
        
        /// <summary>
        /// delegate for Capture
        /// </summary>
        public delegate Action<string, string, string> OnError(string type, string message, string stacktrace);
        /// <summary>
        /// Wrapper for functions to capture exceptions from Electron
        /// </summary>
        /// <exception cref="ElectronException"></exception>
        public static Action<object> Capture(OnError onError)
        {
            void Handler(object value)
            {
                if (Extract(value) is JsError e)
                {
                    onError(e.Type, e.Message, e.StackTrace);
                }
            }
            return Handler;
        }
        /// <summary>
        /// Wrapper for functions to capture exceptions from Electron
        /// </summary>
        /// <exception cref="ElectronException"></exception>
        public static Action<object> Capture(Action<object> action)
        {
            void Handler(object value)
            {
                if (Extract(value) is JsError e)
                {
                    throw new ElectronException(e.Message, e.Type, e.StackTrace);
                }
                action?.Invoke(value);
            }
            return Handler;
        }
        /// <summary>
        /// Wrapper for functions to capture exceptions from Electron
        /// </summary>
        /// <exception cref="ElectronException"></exception>
        public static Action<object> Capture<T>(Action<object> action, TaskCompletionSource<T> tsc)
        {
            void Handler(object value)
            {
                if (Extract(value) is JsError e)
                {
                    try
                    {
                        throw new ElectronException(e.Message, e.Type, e.StackTrace);
                    }
                    catch (Exception ex)
                    {
                        tsc.TrySetException(ex);
                        return;
                    }
                }
                action?.Invoke(value);
            }
            return Handler;
        }
        /// <summary>
        /// Wrapper for functions to capture exceptions from Electron
        /// </summary>
        /// <exception cref="ElectronException"></exception>
        public static Action<object> Capture(Action<object> action, TaskCompletionSource tsc)
        {
            void Handler(object value)
            {
                if (Extract(value) is JsError e)
                {
                    try
                    {
                        throw new ElectronException(e.Message, e.Type, e.StackTrace);
                    }
                    catch (Exception ex)
                    {
                        tsc.TrySetException(ex);
                        return;
                    }
                }
                action?.Invoke(value);
            }
            return Handler;
        }
    }

    /// <inheritdoc />
    public class ElectronException : Exception
    {
        /// <summary>
        /// The type of javascript error
        /// </summary>
        public string JsType { get; }
        /// <summary>
        /// The javascript stacktrace
        /// </summary>
        public string JsStackTrace { get; }

        /// <inheritdoc />
        public ElectronException(string message, string type, string stackTrace)
        {
            JsType = type;
            JsStackTrace = stackTrace;
        }

        public override string ToString()
            => $@"{base.ToString()}
---From Electron---
{JsType}: {Message}
{JsStackTrace}
";
    }
}

API classes that have a callback would be updated to follow this format:

public class BrowserWindow 
{
        ...
        public Task<bool> HasShadowAsync()
        {
            var taskCompletionSource = new TaskCompletionSource<bool>();

            BridgeConnector.Socket.On("browserWindow-hasShadow-completed", ErrorCapture.Capture(hasShadow => {
                BridgeConnector.Socket.Off("browserWindow-hasShadow-completed");

                taskCompletionSource.SetResult((bool)hasShadow);
            }, taskCompletionSource));

            BridgeConnector.Socket.Emit("browserWindowHasShadow", Id);

            return taskCompletionSource.Task;
        }
       ...
}

Client applications would capture unhandled exceptions like this:


Electron.App.On("unhandled-electronnet-error", ErrorCapture.Capture((type, message, stacktrace) => 
{ 
  // do something
});

Final Thoughts

Doing this would mean a large change in the code. We would have to hit many places in both the dotnet and js side of things. This would also mean a large and possibly breaking change for any consumer code as Exception Handling on the .net side would become more paramount. However I believe that the final outcome would be more visibility to the primary developers, i.e. all us dotnet monkeys.

D Gidman

Originally created by @danatcofo on GitHub (Feb 24, 2022). Originally assigned to: @GregorBiswanger on GitHub. > I've developed some of this locally to validate the ideas but feel like this proposal has some large unknowns that should be discussed prior to adoption or implementation thus... please tear this apart with me. One of the things that creates a little bit of a blocker for me as a dotnet developer using Electron.NET is that errors that occur in the electron side of Electron.NET are effectively swallowed. This lack of visibility leads to a lot of time spent diagnosing where an issue occurred (Electron or dotnet) even before figuring out why an issue occurred. To promote visibility of errors in electron I propose the following: --- * For the case where an error occurs and the dotnet side of code is expecting a response but will not receive one: --- return a pre-formatted string with the exception information as the content that the dotnet handler can properly parse and throw a .net exception for. * For the case where an error occurs and the dotnet side of code is not expecting a response: --- Create a channel to except exceptions from the js into the dotnet code. This would be a generic channel to accept the messages from any location we devise. --- ### Electron Implementation ### On the electron side I propose the addition of the following: **postError.ts** ```typescript import { Socket } from 'net'; let electronSocket: Socket; export = (socket:Socket):(message:any, channel: string) => void => { electronSocket = socket; return (message: any, channel: string):void => { let e: Error; if (message instanceof Error) { e = message; } else { try { throw new Error(message); } catch (error) { e = error; } } var errorMessage = `ElectronNETError: ${e.name}: ${e.message}${(e.stack ? `\n--stacktrace--\n${e.stack}` : '')}` electronSocket.emit(channel || 'unhandled-electronnet-error', errorMessage); }; } ``` How this would be consumed in the electron side. ```typescript // from browserWindows.ts export = (socket: Socket, app: Electron.App) => { electronSocket = socket; const postError = require('./postError')(socket); ... // dotnet is expecting a response here socket.on('browserWindowHasShadow', (id) => { const w = getWindowById(id); const channel = 'browserWindow-hasShadow-completed'; if (w) { const hasShadow = w.hasShadow(); electronSocket.emit(channel, hasShadow); } else { postError(`window with id ${id} was not found`, channel); } }); // dotnet is not expecting a response socket.on('browserWindowBlur', (id) => { const w = getWindowById(id); if (w) { w.blur(); } else { postError(`window with id ${id} was not found`); } }); // alternatively we could do socket.on('browserWindowBlur', (id) => { try { getWindowById(id).blur(); } catch (e) { postError(e); } }); ... } ``` ### DotNet Implementation ### On the dotnet side we would have a capture class ```csharp using System; using System.Threading.Tasks; namespace ElectronNET.API { /// <summary></summary> public static class ErrorCapture { private class JsError { public string Type { get; set; } public string Message { get; set; } public string StackTrace { get; set; } } private static object Extract(object value) { if (value is string s && s.StartsWith("ElectronNETError: ")) { var parts = s.Substring(17).Split("\n--stacktrace--\n"); var typeSplit = parts[0].IndexOf(':'); var type = parts[0].Substring(0, typeSplit); var message = parts[0].Substring(typeSplit + 1); var stackTrace = parts.Length > 1 ? parts[parts.Length - 1] : string.Empty; return new JsError { Type = type, Message = message, StackTrace = stackTrace, }; } return value; } /// <summary> /// delegate for Capture /// </summary> public delegate Action<string, string, string> OnError(string type, string message, string stacktrace); /// <summary> /// Wrapper for functions to capture exceptions from Electron /// </summary> /// <exception cref="ElectronException"></exception> public static Action<object> Capture(OnError onError) { void Handler(object value) { if (Extract(value) is JsError e) { onError(e.Type, e.Message, e.StackTrace); } } return Handler; } /// <summary> /// Wrapper for functions to capture exceptions from Electron /// </summary> /// <exception cref="ElectronException"></exception> public static Action<object> Capture(Action<object> action) { void Handler(object value) { if (Extract(value) is JsError e) { throw new ElectronException(e.Message, e.Type, e.StackTrace); } action?.Invoke(value); } return Handler; } /// <summary> /// Wrapper for functions to capture exceptions from Electron /// </summary> /// <exception cref="ElectronException"></exception> public static Action<object> Capture<T>(Action<object> action, TaskCompletionSource<T> tsc) { void Handler(object value) { if (Extract(value) is JsError e) { try { throw new ElectronException(e.Message, e.Type, e.StackTrace); } catch (Exception ex) { tsc.TrySetException(ex); return; } } action?.Invoke(value); } return Handler; } /// <summary> /// Wrapper for functions to capture exceptions from Electron /// </summary> /// <exception cref="ElectronException"></exception> public static Action<object> Capture(Action<object> action, TaskCompletionSource tsc) { void Handler(object value) { if (Extract(value) is JsError e) { try { throw new ElectronException(e.Message, e.Type, e.StackTrace); } catch (Exception ex) { tsc.TrySetException(ex); return; } } action?.Invoke(value); } return Handler; } } /// <inheritdoc /> public class ElectronException : Exception { /// <summary> /// The type of javascript error /// </summary> public string JsType { get; } /// <summary> /// The javascript stacktrace /// </summary> public string JsStackTrace { get; } /// <inheritdoc /> public ElectronException(string message, string type, string stackTrace) { JsType = type; JsStackTrace = stackTrace; } public override string ToString() => $@"{base.ToString()} ---From Electron--- {JsType}: {Message} {JsStackTrace} "; } } ``` API classes that have a callback would be updated to follow this format: ```csharp public class BrowserWindow { ... public Task<bool> HasShadowAsync() { var taskCompletionSource = new TaskCompletionSource<bool>(); BridgeConnector.Socket.On("browserWindow-hasShadow-completed", ErrorCapture.Capture(hasShadow => { BridgeConnector.Socket.Off("browserWindow-hasShadow-completed"); taskCompletionSource.SetResult((bool)hasShadow); }, taskCompletionSource)); BridgeConnector.Socket.Emit("browserWindowHasShadow", Id); return taskCompletionSource.Task; } ... } ``` Client applications would capture unhandled exceptions like this: ```csharp Electron.App.On("unhandled-electronnet-error", ErrorCapture.Capture((type, message, stacktrace) => { // do something }); ``` --- ### Final Thoughts ### Doing this would mean a large change in the code. We would have to hit many places in both the dotnet and js side of things. This would also mean a large and possibly breaking change for any consumer code as Exception Handling on the .net side would become more paramount. However I believe that the final outcome would be more visibility to the primary developers, i.e. all us dotnet monkeys. D Gidman

claunia added the Feature label 2026-01-29 16:48:09 +00:00

claunia closed this issue

2026-01-29 16:48:10 +00:00

claunia commented

2026-01-29 16:48:11 +00:00

@GregorBiswanger commented on GitHub (Mar 28, 2023):

🎉🚀 New Electron.NET version 23.6.1 released 🚀🎉

With native Electron 23 and .NET 6 support. Your problem should be fixed here. If you continue to have the problem, please let us know. Please note the correct updating of your API & CLI. Info in the README. Have fun!

@GregorBiswanger commented on GitHub (Mar 28, 2023): 🎉🚀 New Electron.NET version 23.6.1 released 🚀🎉 With native Electron 23 and .NET 6 support. Your problem should be fixed here. If you continue to have the problem, please let us know. Please note the correct updating of your API & CLI. Info in the README. Have fun!

Sign in to join this conversation.

1 Participants

Notifications

Due Date

No due date set.

Dependencies

No dependencies set.

Reference: starred/Electron.NET#769