Merge pull request #595 from theolivenbaum/switch-to-new-socket-lib

Switch to async socket lib

ElectronNET.API/AutoUpdater.cs

@@ -13,31 +13,43 @@ namespace ElectronNET.API
     /// </summary>
     public sealed class AutoUpdater
     {
+        /// <summary>
+        /// Whether to automatically download an update when it is found. (Default is true)
+        /// </summary>
+        public Task<bool> IsAutoDownloadEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-autoDownload-get", "autoUpdater-autoDownload-get-reply");
+
+        /// <summary>
+        /// Whether to automatically install a downloaded update on app quit (if `QuitAndInstall` was not called before).
+        /// 
+        /// Applicable only on Windows and Linux.
+        /// </summary>
+        public Task<bool> IsAutoInstallOnAppQuitEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-autoInstallOnAppQuit-get", "autoUpdater-autoInstallOnAppQuit-get-reply");
+
+        /// <summary>
+        /// *GitHub provider only.* Whether to allow update to pre-release versions. 
+        /// Defaults to "true" if application version contains prerelease components (e.g. "0.12.1-alpha.1", here "alpha" is a prerelease component), otherwise "false".
+        /// 
+        /// If "true", downgrade will be allowed("allowDowngrade" will be set to "true").
+        /// </summary>
+        public Task<bool> IsAllowPrereleaseEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-allowPrerelease-get", "autoUpdater-allowPrerelease-get-reply");
+
+        /// <summary>
+        /// *GitHub provider only.* 
+        /// Get all release notes (from current version to latest), not just the latest (Default is false).
+        /// </summary>
+        public Task<bool> IsFullChangeLogEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-fullChangelog-get", "autoUpdater-fullChangelog-get-reply");
+
+        public Task<bool> IsAllowDowngradeEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-allowDowngrade-get", "autoUpdater-allowDowngrade-get-reply");
+        
+
         /// <summary>
         /// Whether to automatically download an update when it is found. (Default is true)
         /// </summary>
         public bool AutoDownload
         {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-autoDownload-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-autoDownload-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-autoDownload-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-autoDownload-set", value);
+                BridgeConnector.Emit("autoUpdater-autoDownload-set", value);
             }
         }
 
@@ -48,26 +60,9 @@ namespace ElectronNET.API
         /// </summary>
         public bool AutoInstallOnAppQuit
         {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-autoInstallOnAppQuit-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-autoInstallOnAppQuit-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-autoInstallOnAppQuit-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-autoInstallOnAppQuit-set", value);
+                BridgeConnector.Emit("autoUpdater-autoInstallOnAppQuit-set", value);
             }
         }
 
@@ -79,26 +74,9 @@ namespace ElectronNET.API
         /// </summary>
         public bool AllowPrerelease
         {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-allowPrerelease-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-allowPrerelease-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-allowPrerelease-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-allowPrerelease-set", value);
+                BridgeConnector.Emit("autoUpdater-allowPrerelease-set", value);
             }
         }
 
@@ -108,26 +86,9 @@ namespace ElectronNET.API
         /// </summary>
         public bool FullChangelog
         {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-fullChangelog-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-fullChangelog-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-fullChangelog-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-fullChangelog-set", value);
+                BridgeConnector.Emit("autoUpdater-fullChangelog-set", value);
             }
         }
 
@@ -138,137 +99,32 @@ namespace ElectronNET.API
         /// </summary>
         public bool AllowDowngrade
         {
-            get
-            {
-                return Task.Run<bool>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<bool>();
-
-                    BridgeConnector.Socket.On("autoUpdater-allowDowngrade-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-allowDowngrade-get-reply");
-                        taskCompletionSource.SetResult((bool)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-allowDowngrade-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-allowDowngrade-set", value);
+                BridgeConnector.Emit("autoUpdater-allowDowngrade-set", value);
             }
         }
 
         /// <summary>
         /// For test only.
         /// </summary>
-        public string UpdateConfigPath
-        {
-            get
-            {
-                return Task.Run<string>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<string>();
-
-                    BridgeConnector.Socket.On("autoUpdater-updateConfigPath-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-updateConfigPath-get-reply");
-                        taskCompletionSource.SetResult(result.ToString());
-                    });
-
-                    BridgeConnector.Socket.Emit("autoUpdater-updateConfigPath-get");
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
-        }
+        public Task<string> GetUpdateConfigPathAsync() => BridgeConnector.OnResult<string>("autoUpdater-updateConfigPath-get", "autoUpdater-updateConfigPath-get-reply");
 
         /// <summary>
         /// The current application version
         /// </summary>
-        public Task<SemVer> CurrentVersionAsync
-        {
-            get
-            {
-                return Task.Run<SemVer>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<SemVer>();
-
-                    BridgeConnector.Socket.On("autoUpdater-currentVersion-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-currentVersion-get-reply");
-                        SemVer version = ((JObject)result).ToObject<SemVer>();
-                        taskCompletionSource.SetResult(version);
-                    });
-                    BridgeConnector.Socket.Emit("autoUpdater-currentVersion-get");
-
-                    return taskCompletionSource.Task;
-                });
-            }
-        }
+        public Task<SemVer> GetCurrentVersionAsync() => BridgeConnector.OnResult<SemVer>("autoUpdater-updateConcurrentVersionfigPath-get", "autoUpdater-currentVersion-get-reply");
 
         /// <summary>
         /// Get the update channel. Not applicable for GitHub. 
         /// Doesn’t return channel from the update configuration, only if was previously set.
         /// </summary>
-        [Obsolete("Use the asynchronous version ChannelAsync instead")]
-        public string Channel
-        {
-            get
-            {
-                return ChannelAsync.Result;
-            }
-        }
-
-        /// <summary>
-        /// Get the update channel. Not applicable for GitHub. 
-        /// Doesn’t return channel from the update configuration, only if was previously set.
-        /// </summary>
-        public Task<string> ChannelAsync
-        {
-            get
-            {
-                return Task.Run<string>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<string>();
-
-                    BridgeConnector.Socket.On("autoUpdater-channel-get-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-channel-get-reply");
-                        taskCompletionSource.SetResult(result.ToString());
-                    });
-                    BridgeConnector.Socket.Emit("autoUpdater-channel-get");
-
-                    return taskCompletionSource.Task;
-                });
-            }
-        }
-
-
+        public Task<string> GetChannelAsync() => BridgeConnector.OnResult<string>("autoUpdater-channel-get", "autoUpdater-channel-get-reply");
 
         /// <summary>
         /// The request headers.
         /// </summary>
-        public Task<Dictionary<string, string>> RequestHeadersAsync
-        {
-            get
-            {
-                return Task.Run(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<Dictionary<string, string>>();
-                    BridgeConnector.Socket.On("autoUpdater-requestHeaders-get-reply", (headers) =>
-                    {
-                        BridgeConnector.Socket.Off("autoUpdater-requestHeaders-get-reply");
-                        Dictionary<string, string> result = ((JObject)headers).ToObject<Dictionary<string, string>>();
-                        taskCompletionSource.SetResult(result);
-                    });
-                    BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-get");
-                    return taskCompletionSource.Task;
-                });
-            }
-        }
+        public Task<Dictionary<string, string>> GetRequestHeadersAsync() => BridgeConnector.OnResult<Dictionary<string, string>>("autoUpdater-requestHeaders-get", "autoUpdater-requestHeaders-get-reply");
 
         /// <summary>
         /// The request headers.
@@ -277,7 +133,7 @@ namespace ElectronNET.API
         {
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-set", JObject.FromObject(value, _jsonSerializer));
+                BridgeConnector.Emit("autoUpdater-requestHeaders-set", value);
             }
         }
 
@@ -290,12 +146,12 @@ namespace ElectronNET.API
             {
                 if (_error == null)
                 {
-                    BridgeConnector.Socket.On("autoUpdater-error" + GetHashCode(), (message) =>
+                    BridgeConnector.On<string>("autoUpdater-error" + GetHashCode(), (message) =>
                     {
                         _error(message.ToString());
                     });
 
-                    BridgeConnector.Socket.Emit("register-autoUpdater-error-event", GetHashCode());
+                    BridgeConnector.Emit("register-autoUpdater-error-event", GetHashCode());
                 }
                 _error += value;
             }
@@ -304,7 +160,7 @@ namespace ElectronNET.API
                 _error -= value;
 
                 if (_error == null)
-                    BridgeConnector.Socket.Off("autoUpdater-error" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-error" + GetHashCode());
             }
         }
 
@@ -319,12 +175,12 @@ namespace ElectronNET.API
             {
                 if (_checkingForUpdate == null)
                 {
-                    BridgeConnector.Socket.On("autoUpdater-checking-for-update" + GetHashCode(), () =>
+                    BridgeConnector.On("autoUpdater-checking-for-update" + GetHashCode(), () =>
                     {
                         _checkingForUpdate();
                     });
 
-                    BridgeConnector.Socket.Emit("register-autoUpdater-checking-for-update-event", GetHashCode());
+                    BridgeConnector.Emit("register-autoUpdater-checking-for-update-event", GetHashCode());
                 }
                 _checkingForUpdate += value;
             }
@@ -333,7 +189,7 @@ namespace ElectronNET.API
                 _checkingForUpdate -= value;
 
                 if (_checkingForUpdate == null)
-                    BridgeConnector.Socket.Off("autoUpdater-checking-for-update" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-checking-for-update" + GetHashCode());
             }
         }
 
@@ -349,12 +205,12 @@ namespace ElectronNET.API
             {
                 if (_updateAvailable == null)
                 {
-                    BridgeConnector.Socket.On("autoUpdater-update-available" + GetHashCode(), (updateInfo) =>
+                    BridgeConnector.On<UpdateInfo>("autoUpdater-update-available" + GetHashCode(), (updateInfo) =>
                     {
-                        _updateAvailable(JObject.Parse(updateInfo.ToString()).ToObject<UpdateInfo>());
+                        _updateAvailable(updateInfo);
                     });
 
-                    BridgeConnector.Socket.Emit("register-autoUpdater-update-available-event", GetHashCode());
+                    BridgeConnector.Emit("register-autoUpdater-update-available-event", GetHashCode());
                 }
                 _updateAvailable += value;
             }
@@ -363,7 +219,7 @@ namespace ElectronNET.API
                 _updateAvailable -= value;
 
                 if (_updateAvailable == null)
-                    BridgeConnector.Socket.Off("autoUpdater-update-available" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-update-available" + GetHashCode());
             }
         }
 
@@ -378,12 +234,12 @@ namespace ElectronNET.API
             {
                 if (_updateNotAvailable == null)
                 {
-                    BridgeConnector.Socket.On("autoUpdater-update-not-available" + GetHashCode(), (updateInfo) =>
+                    BridgeConnector.On<UpdateInfo>("autoUpdater-update-not-available" + GetHashCode(), (updateInfo) =>
                     {
-                        _updateNotAvailable(JObject.Parse(updateInfo.ToString()).ToObject<UpdateInfo>());
+                        _updateNotAvailable(updateInfo);
                     });
 
-                    BridgeConnector.Socket.Emit("register-autoUpdater-update-not-available-event", GetHashCode());
+                    BridgeConnector.Emit("register-autoUpdater-update-not-available-event", GetHashCode());
                 }
                 _updateNotAvailable += value;
             }
@@ -392,7 +248,7 @@ namespace ElectronNET.API
                 _updateNotAvailable -= value;
 
                 if (_updateNotAvailable == null)
-                    BridgeConnector.Socket.Off("autoUpdater-update-not-available" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-update-not-available" + GetHashCode());
             }
         }
 
@@ -407,12 +263,12 @@ namespace ElectronNET.API
             {
                 if (_downloadProgress == null)
                 {
-                    BridgeConnector.Socket.On("autoUpdater-download-progress" + GetHashCode(), (progressInfo) =>
+                    BridgeConnector.On<ProgressInfo>("autoUpdater-download-progress" + GetHashCode(), (progressInfo) =>
                     {
-                        _downloadProgress(JObject.Parse(progressInfo.ToString()).ToObject<ProgressInfo>());
+                        _downloadProgress(progressInfo);
                     });
 
-                    BridgeConnector.Socket.Emit("register-autoUpdater-download-progress-event", GetHashCode());
+                    BridgeConnector.Emit("register-autoUpdater-download-progress-event", GetHashCode());
                 }
                 _downloadProgress += value;
             }
@@ -421,7 +277,7 @@ namespace ElectronNET.API
                 _downloadProgress -= value;
 
                 if (_downloadProgress == null)
-                    BridgeConnector.Socket.Off("autoUpdater-download-progress" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-download-progress" + GetHashCode());
             }
         }
 
@@ -436,12 +292,12 @@ namespace ElectronNET.API
             {
                 if (_updateDownloaded == null)
                 {
-                    BridgeConnector.Socket.On("autoUpdater-update-downloaded" + GetHashCode(), (updateInfo) =>
+                    BridgeConnector.On<UpdateInfo>("autoUpdater-update-downloaded" + GetHashCode(), (updateInfo) =>
                     {
-                        _updateDownloaded(JObject.Parse(updateInfo.ToString()).ToObject<UpdateInfo>());
+                        _updateDownloaded(updateInfo);
                     });
 
-                    BridgeConnector.Socket.Emit("register-autoUpdater-update-downloaded-event", GetHashCode());
+                    BridgeConnector.Emit("register-autoUpdater-update-downloaded-event", GetHashCode());
                 }
                 _updateDownloaded += value;
             }
@@ -450,7 +306,7 @@ namespace ElectronNET.API
                 _updateDownloaded -= value;
 
                 if (_updateDownloaded == null)
-                    BridgeConnector.Socket.Off("autoUpdater-update-downloaded" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-update-downloaded" + GetHashCode());
             }
         }
 
@@ -486,33 +342,33 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<UpdateCheckResult> CheckForUpdatesAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
+            var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesComplete" + guid, (updateCheckResult) =>
+            BridgeConnector.On<UpdateCheckResult>("autoUpdaterCheckForUpdatesComplete" + guid, (updateCheckResult) =>
             {
                 try
                 {
-                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
-                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
-                    taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                    BridgeConnector.Off("autoUpdaterCheckForUpdatesComplete" + guid);
+                    BridgeConnector.Off("autoUpdaterCheckForUpdatesError" + guid);
+                    taskCompletionSource.SetResult(updateCheckResult);
                 }
                 catch (Exception ex)
                 {
                     taskCompletionSource.SetException(ex);
                 }
             });
-            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesError" + guid, (error) =>
+            BridgeConnector.On<string>("autoUpdaterCheckForUpdatesError" + guid, (error) =>
             {
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
+                BridgeConnector.Off("autoUpdaterCheckForUpdatesComplete" + guid);
+                BridgeConnector.Off("autoUpdaterCheckForUpdatesError" + guid);
                 string message = "An error occurred in CheckForUpdatesAsync";
                 if (error != null && !string.IsNullOrEmpty(error.ToString()))
                     message = JsonConvert.SerializeObject(error);
                 taskCompletionSource.SetException(new Exception(message));
             });
 
-            BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdates", guid);
+            BridgeConnector.Emit("autoUpdaterCheckForUpdates", guid);
 
             return taskCompletionSource.Task;
         }
@@ -525,36 +381,36 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<UpdateCheckResult> CheckForUpdatesAndNotifyAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
+            var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid, (updateCheckResult) =>
+            BridgeConnector.On<UpdateCheckResult>("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid, (updateCheckResult) =>
             {
                 try
                 {
-                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
-                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
+                    BridgeConnector.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
+                    BridgeConnector.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
                     if (updateCheckResult == null)
                         taskCompletionSource.SetResult(null);
                     else
-                        taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                        taskCompletionSource.SetResult(updateCheckResult);
                 }
                 catch (Exception ex)
                 {
                     taskCompletionSource.SetException(ex);
                 }
             });
-            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyError" + guid, (error) =>
+            BridgeConnector.On<string>("autoUpdaterCheckForUpdatesAndNotifyError" + guid, (error) =>
             {
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
-                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
+                BridgeConnector.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
+                BridgeConnector.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
                 string message = "An error occurred in autoUpdaterCheckForUpdatesAndNotify";
                 if (error != null)
                     message = JsonConvert.SerializeObject(error);
                 taskCompletionSource.SetException(new Exception(message));
             });
 
-            BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdatesAndNotify", guid);
+            BridgeConnector.Emit("autoUpdaterCheckForUpdatesAndNotify", guid);
 
             return taskCompletionSource.Task;
         }
@@ -570,7 +426,7 @@ namespace ElectronNET.API
         /// <param name="isForceRunAfter">Run the app after finish even on silent install. Not applicable for macOS. Ignored if `isSilent` is set to `false`.</param>
         public void QuitAndInstall(bool isSilent = false, bool isForceRunAfter = false)
         {
-            BridgeConnector.Socket.Emit("autoUpdaterQuitAndInstall", isSilent, isForceRunAfter);
+            BridgeConnector.EmitSync("autoUpdaterQuitAndInstall", isSilent, isForceRunAfter);
         }
 
         /// <summary>
@@ -579,16 +435,16 @@ namespace ElectronNET.API
         /// <returns>Path to downloaded file.</returns>
         public Task<string> DownloadUpdateAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<string>();
+            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("autoUpdaterDownloadUpdateComplete" + guid, (downloadedPath) =>
+            BridgeConnector.On<string>("autoUpdaterDownloadUpdateComplete" + guid, (downloadedPath) =>
             {
-                BridgeConnector.Socket.Off("autoUpdaterDownloadUpdateComplete" + guid);
+                BridgeConnector.Off("autoUpdaterDownloadUpdateComplete" + guid);
                 taskCompletionSource.SetResult(downloadedPath.ToString());
             });
 
-            BridgeConnector.Socket.Emit("autoUpdaterDownloadUpdate", guid);
+            BridgeConnector.Emit("autoUpdaterDownloadUpdate", guid);
 
             return taskCompletionSource.Task;
         }
@@ -599,23 +455,18 @@ namespace ElectronNET.API
         /// <returns>Feed URL.</returns>
         public Task<string> GetFeedURLAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<string>();
+            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("autoUpdaterGetFeedURLComplete" + guid, (downloadedPath) =>
+            BridgeConnector.On<string>("autoUpdaterGetFeedURLComplete" + guid, (downloadedPath) =>
             {
-                BridgeConnector.Socket.Off("autoUpdaterGetFeedURLComplete" + guid);
+                BridgeConnector.Off("autoUpdaterGetFeedURLComplete" + guid);
                 taskCompletionSource.SetResult(downloadedPath.ToString());
             });
 
-            BridgeConnector.Socket.Emit("autoUpdaterGetFeedURL", guid);
+            BridgeConnector.Emit("autoUpdaterGetFeedURL", guid);
 
             return taskCompletionSource.Task;
         }
-
-        private readonly JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver()
-        };
     }
 }

ElectronNET.API/BridgeConnector.cs

@@ -1,44 +1,318 @@
-using Quobject.SocketIoClientDotNet.Client;
-using System;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using SocketIOClient;
+using SocketIOClient.JsonSerializer;
+using SocketIOClient.Newtonsoft.Json;
 
 namespace ElectronNET.API
 {
     internal static class BridgeConnector
     {
-        private static Socket _socket;
+        internal static class EventTasks<T>
+        {
+            //Although SocketIO already manage event handlers, we need to manage this here as well for the OnResult calls,
+            //because SocketIO will simply replace the existing event handler on every call to On(key, ...) , which means there is 
+            //a race condition between On / Off calls that can lead to tasks deadlocking forever without ever triggering their On handler
+
+            private static readonly Dictionary<string, TaskCompletionSource<T>> _taskCompletionSources = new();
+            private static readonly Dictionary<string, string> _eventKeys = new();
+            private static readonly object _lock = new();
+
+            /// <summary>
+            /// Get or add a new TaskCompletionSource<typeparamref name="T"/> for a given event key
+            /// </summary>
+            /// <param name="key"></param>
+            /// <param name="eventKey"></param>
+            /// <param name="taskCompletionSource"></param>
+            /// <param name="waitThisFirstAndThenTryAgain"></param>
+            /// <returns>Returns true if a new TaskCompletionSource<typeparamref name="T"/> was added to the dictionary</returns>
+            internal static bool TryGetOrAdd(string key, string eventKey, out TaskCompletionSource<T> taskCompletionSource, out Task waitThisFirstAndThenTryAgain)
+            {
+                lock (_lock)
+                {
+                    if (!_taskCompletionSources.TryGetValue(key, out taskCompletionSource))
+                    {
+                        taskCompletionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
+                        _taskCompletionSources[key] = taskCompletionSource;
+                        _eventKeys[key] = eventKey;
+                        waitThisFirstAndThenTryAgain = null;
+                        return true; //Was added, so we need to also register the socket events
+                    }
+
+                    if(_eventKeys.TryGetValue(key, out var existingEventKey) && existingEventKey == eventKey)
+                    {
+                        waitThisFirstAndThenTryAgain = null;
+                        return false; //No need to register the socket events twice
+                    }
+
+                    waitThisFirstAndThenTryAgain = taskCompletionSource.Task; //Will need to try again after the previous existing one is done
+
+                    taskCompletionSource = null;
+
+                    return true; //Need to register the socket events, but must first await the previous task to complete
+                }
+            }
+
+            /// <summary>
+            /// Clean up the TaskCompletionSource<typeparamref name="T"/> from the dictionary if and only if it is the same as the passed argument
+            /// </summary>
+            /// <param name="key"></param>
+            /// <param name="eventKey"></param>
+            /// <param name="taskCompletionSource"></param>
+            internal static void DoneWith(string key, string eventKey, TaskCompletionSource<T> taskCompletionSource)
+            {
+                lock (_lock)
+                {
+                    if (_taskCompletionSources.TryGetValue(key, out var existingTaskCompletionSource)
+                        && ReferenceEquals(existingTaskCompletionSource, taskCompletionSource))
+                    {
+                        _taskCompletionSources.Remove(key);
+                    }
+
+                    if (_eventKeys.TryGetValue(key, out var existingEventKey) && existingEventKey == eventKey)
+                    {
+                        _eventKeys.Remove(key);
+                    }
+                }
+            }
+        }
+
+        private static SocketIO _socket;
+
         private static object _syncRoot = new object();
 
-        public static Socket Socket
+        public static void Emit(string eventString, params object[] args)
+        {
+            //We don't care about waiting for the event to be emitted, so this doesn't need to be async 
+
+            Task.Run(async () =>
+            {
+                if (App.SocketDebug)
+                {
+                    Console.WriteLine($"Sending event {eventString}");
+                }
+
+                await Socket.EmitAsync(eventString, args);
+
+                if (App.SocketDebug)
+                {
+                    Console.WriteLine($"Sent event {eventString}");
+                }
+            });
+        }
+
+        /// <summary>
+        /// This method is only used on places where we need to be sure the event was sent on the socket, such as Quit, Exit, Relaunch and QuitAndInstall methods
+        /// </summary>
+        /// <param name="eventString"></param>
+        /// <param name="args"></param>
+        internal static void EmitSync(string eventString, params object[] args)
+        {
+            if (App.SocketDebug)
+            {
+                Console.WriteLine($"Sending event {eventString}");
+            }
+
+            Socket.EmitAsync(eventString, args).Wait();
+
+            if (App.SocketDebug)
+            {
+                Console.WriteLine($"Sent event {eventString}");
+            }
+        }
+
+        public static void Off(string eventString)
+        {
+            Socket.Off(eventString);
+        }
+
+        public static void On(string eventString, Action fn)
+        {
+            Socket.On(eventString, _ => fn());
+        }
+
+        public static void On<T>(string eventString, Action<T> fn)
+        {
+            Socket.On(eventString, (o) => fn(o.GetValue<T>(0)));
+        }
+
+        public static void Once<T>(string eventString, Action<T> fn)
+        {
+            On<T>(eventString, (o) =>
+            {
+                Off(eventString);
+                fn(o);
+            });
+        }
+
+        public static async Task<T> OnResult<T>(string triggerEvent, string completedEvent, params object[] args)
+        {
+            string eventKey = completedEvent;
+
+            if (args is object && args.Length > 0) // If there are arguments passed, we generate a unique event key with the arguments
+                                                   // this allow us to wait for previous events first before registering new ones
+            {
+                var hash = new HashCode();
+                foreach(var obj in args)
+                {
+                    hash.Add(obj);
+                }
+                eventKey = $"{eventKey}-{(uint)hash.ToHashCode()}";
+            }
+
+            if (EventTasks<T>.TryGetOrAdd(completedEvent, eventKey, out var taskCompletionSource, out var waitThisFirstAndThenTryAgain))
+            {
+                if (waitThisFirstAndThenTryAgain is object)
+                {
+                    //There was a pending call with different parameters, so we need to wait that first and then call here again
+                    try
+                    {
+                        await waitThisFirstAndThenTryAgain;
+                    }
+                    catch
+                    {
+                        //Ignore any exceptions here so we can set a new event below
+                        //The exception will also be visible to the original first caller due to taskCompletionSource.Task
+                    }
+
+                    //Try again to set the event
+                    return await OnResult<T>(triggerEvent, completedEvent, args);
+                }
+                else
+                {
+                    //A new TaskCompletionSource was added, so we need to register the completed event here
+
+                    On<T>(completedEvent, (result) =>
+                    {
+                        Off(completedEvent);
+                        taskCompletionSource.SetResult(result);
+                        EventTasks<T>.DoneWith(completedEvent, eventKey, taskCompletionSource);
+                    });
+
+                    Emit(triggerEvent, args);
+                }
+            }
+
+            return await taskCompletionSource.Task;
+        }
+
+
+        public static async Task<T> OnResult<T>(string triggerEvent, string completedEvent, CancellationToken cancellationToken, params object[] args)
+        {
+            string eventKey = completedEvent;
+
+            if (args is object && args.Length > 0) // If there are arguments passed, we generate a unique event key with the arguments
+                                                   // this allow us to wait for previous events first before registering new ones
+            {
+                var hash = new HashCode();
+                foreach (var obj in args)
+                {
+                    hash.Add(obj);
+                }
+                eventKey = $"{eventKey}-{(uint)hash.ToHashCode()}";
+            }
+
+            if (EventTasks<T>.TryGetOrAdd(completedEvent, eventKey, out var taskCompletionSource, out var waitThisFirstAndThenTryAgain))
+            {
+                if (waitThisFirstAndThenTryAgain is object)
+                {
+                    //There was a pending call with different parameters, so we need to wait that first and then call here again
+                    try
+                    {
+                        await Task.Run(() => waitThisFirstAndThenTryAgain, cancellationToken);
+                    }
+                    catch
+                    {
+                        //Ignore any exceptions here so we can set a new event below
+                        //The exception will also be visible to the original first caller due to taskCompletionSource.Task
+                    }
+
+                    //Try again to set the event
+                    return await OnResult<T>(triggerEvent, completedEvent, cancellationToken, args);
+                }
+                else
+                {
+                    using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+                    {
+                        //A new TaskCompletionSource was added, so we need to register the completed event here
+
+                        On<T>(completedEvent, (result) =>
+                        {
+                            Off(completedEvent);
+                            taskCompletionSource.SetResult(result);
+                            EventTasks<T>.DoneWith(completedEvent, eventKey, taskCompletionSource);
+                        });
+
+                        Emit(triggerEvent, args);
+                    }
+                }
+            }
+
+            return await taskCompletionSource.Task;
+        }
+        private static SocketIO Socket
         {
             get
             {
-                if(_socket == null && HybridSupport.IsElectronActive)
+                if (_socket is null)
                 {
-                    lock (_syncRoot)
+                    if (HybridSupport.IsElectronActive)
                     {
-                        if (_socket == null && HybridSupport.IsElectronActive)
+
+                        lock (_syncRoot)
                         {
-                            _socket = IO.Socket("http://localhost:" + BridgeSettings.SocketPort);
-                            _socket.On(Socket.EVENT_CONNECT, () =>
+                            if (_socket is null && HybridSupport.IsElectronActive)
                             {
-                                Console.WriteLine("BridgeConnector connected!");
-                            });
+                                var socket = new SocketIO($"http://localhost:{BridgeSettings.SocketPort}", new SocketIOOptions()
+                                {
+                                    EIO = 3
+                                });
+
+                                socket.JsonSerializer = new CamelCaseNewtonsoftJsonSerializer(socket.Options.EIO);
+
+
+                                socket.OnConnected += (_, __) =>
+                                {
+                                    Console.WriteLine("BridgeConnector connected!");
+                                };
+
+                                socket.ConnectAsync().Wait();
+
+                                _socket = socket;
+                            }
                         }
                     }
-                }
-                else if(_socket == null && !HybridSupport.IsElectronActive)
-                {
-                    lock (_syncRoot)
+                    else
                     {
-                        if (_socket == null && !HybridSupport.IsElectronActive)
-                        {
-                            _socket = IO.Socket(new Uri("http://localhost"), new IO.Options { AutoConnect = false });
-                        }
+                        throw new Exception("Missing Socket Port");
                     }
                 }
 
                 return _socket;
             }
         }
+
+        private class CamelCaseNewtonsoftJsonSerializer : NewtonsoftJsonSerializer
+        {
+            public CamelCaseNewtonsoftJsonSerializer(int eio) : base(eio)
+            {
+            }
+
+            public override JsonSerializerSettings CreateOptions()
+            {
+                return new JsonSerializerSettings()
+                {
+                    ContractResolver = new CamelCasePropertyNamesContractResolver(),
+                    NullValueHandling = NullValueHandling.Ignore,
+                    DefaultValueHandling = DefaultValueHandling.Ignore
+                };
+            }
+        }
     }
 }

ElectronNET.API/BridgeSettings.cs

@@ -20,5 +20,16 @@
         /// The web port.
         /// </value>
         public static string WebPort { get; internal set; }
+
+        /// <summary>
+        /// Manually set the port values instead of using the UseElectron extension method
+        /// </summary>
+        /// <param name="socketPort"></param>
+        /// <param name="webPort"></param>
+        public static void InitializePorts(int socketPort, int webPort)
+        {
+            SocketPort = socketPort.ToString();
+            WebPort    = webPort.ToString();
+        }
     }
 }

ElectronNET.API/BrowserView.cs

@@ -31,29 +31,11 @@ namespace ElectronNET.API
         /// 
         /// (experimental)
         /// </summary>
-        public Rectangle Bounds
+        public Task<Rectangle> GetBoundsAsync() => BridgeConnector.OnResult<Rectangle>("browserView-getBounds", "browserView-getBounds-reply" + Id, Id);
+
+        public void SetBounds(Rectangle value)
         {
-            get
-            {
-                return Task.Run<Rectangle>(() =>
-                {
-                    var taskCompletionSource = new TaskCompletionSource<Rectangle>();
-
-                    BridgeConnector.Socket.On("browserView-getBounds-reply", (result) =>
-                    {
-                        BridgeConnector.Socket.Off("browserView-getBounds-reply");
-                        taskCompletionSource.SetResult((Rectangle)result);
-                    });
-
-                    BridgeConnector.Socket.Emit("browserView-getBounds", Id);
-
-                    return taskCompletionSource.Task;
-                }).Result;
-            }
-            set
-            {
-                BridgeConnector.Socket.Emit("browserView-setBounds", Id, JObject.FromObject(value, _jsonSerializer));
-            }
+            BridgeConnector.Emit("browserView-setBounds", Id, value);
         }
 
         /// <summary>
@@ -74,7 +56,7 @@ namespace ElectronNET.API
         /// <param name="options"></param>
         public void SetAutoResize(AutoResizeOptions options)
         {
-            BridgeConnector.Socket.Emit("browserView-setAutoResize", Id, JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("browserView-setAutoResize", Id, options);
         }
 
         /// <summary>
@@ -85,13 +67,7 @@ namespace ElectronNET.API
         /// <param name="color">Color in #aarrggbb or #argb form. The alpha channel is optional.</param>
         public void SetBackgroundColor(string color)
         {
-            BridgeConnector.Socket.Emit("browserView-setBackgroundColor", Id, color);
+            BridgeConnector.Emit("browserView-setBackgroundColor", Id, color);
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore
-        };
     }
 }

ElectronNET.API/Clipboard.cs

@@ -40,21 +40,7 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="type"></param>
         /// <returns>The content in the clipboard as plain text.</returns>
-        public Task<string> ReadTextAsync(string type = "")
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("clipboard-readText-Completed", (text) =>
-            {
-                BridgeConnector.Socket.Off("clipboard-readText-Completed");
-
-                taskCompletionSource.SetResult(text.ToString());
-            });
-
-            BridgeConnector.Socket.Emit("clipboard-readText", type);
-
-            return taskCompletionSource.Task;
-        }
+        public Task<string> ReadTextAsync(string type = "") => BridgeConnector.OnResult<string>("clipboard-readText", "clipboard-readText-Completed", type);
 
         /// <summary>
         /// Writes the text into the clipboard as plain text.
@@ -63,7 +49,7 @@ namespace ElectronNET.API
         /// <param name="type"></param>
         public void WriteText(string text, string type = "")
         {
-            BridgeConnector.Socket.Emit("clipboard-writeText", text, type);
+            BridgeConnector.Emit("clipboard-writeText", text, type);
         }
 
         /// <summary>
@@ -71,21 +57,7 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="type"></param>
         /// <returns></returns>
-        public Task<string> ReadHTMLAsync(string type = "")
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("clipboard-readHTML-Completed", (text) =>
-            {
-                BridgeConnector.Socket.Off("clipboard-readHTML-Completed");
-
-                taskCompletionSource.SetResult(text.ToString());
-            });
-
-            BridgeConnector.Socket.Emit("clipboard-readHTML", type);
-
-            return taskCompletionSource.Task;
-        }
+        public Task<string> ReadHTMLAsync(string type = "") => BridgeConnector.OnResult<string>("clipboard-readHTML", "clipboard-readHTML-Completed", type);
 
         /// <summary>
         /// Writes markup to the clipboard.
@@ -94,7 +66,7 @@ namespace ElectronNET.API
         /// <param name="type"></param>
         public void WriteHTML(string markup, string type = "")
         {
-            BridgeConnector.Socket.Emit("clipboard-writeHTML", markup, type);
+            BridgeConnector.Emit("clipboard-writeHTML", markup, type);
         }
 
         /// <summary>
@@ -102,21 +74,8 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="type"></param>
         /// <returns></returns>
-        public Task<string> ReadRTFAsync(string type = "")
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>();
+        public Task<string> ReadRTFAsync(string type = "") => BridgeConnector.OnResult<string>("clipboard-readRTF", "clipboard-readRTF-Completed", type);
 
-            BridgeConnector.Socket.On("clipboard-readRTF-Completed", (text) =>
-            {
-                BridgeConnector.Socket.Off("clipboard-readRTF-Completed");
-
-                taskCompletionSource.SetResult(text.ToString());
-            });
-
-            BridgeConnector.Socket.Emit("clipboard-readRTF", type);
-
-            return taskCompletionSource.Task;
-        }
 
         /// <summary>
         /// Writes the text into the clipboard in RTF.
@@ -125,7 +84,7 @@ namespace ElectronNET.API
         /// <param name="type"></param>
         public void WriteRTF(string text, string type = "")
         {
-            BridgeConnector.Socket.Emit("clipboard-writeHTML", text, type);
+            BridgeConnector.Emit("clipboard-writeHTML", text, type);
         }
 
         /// <summary>
@@ -134,21 +93,7 @@ namespace ElectronNET.API
         /// be empty strings when the bookmark is unavailable.
         /// </summary>
         /// <returns></returns>
-        public Task<ReadBookmark> ReadBookmarkAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<ReadBookmark>();
-
-            BridgeConnector.Socket.On("clipboard-readBookmark-Completed", (bookmark) =>
-            {
-                BridgeConnector.Socket.Off("clipboard-readBookmark-Completed");
-
-                taskCompletionSource.SetResult(((JObject)bookmark).ToObject<ReadBookmark>());
-            });
-
-            BridgeConnector.Socket.Emit("clipboard-readBookmark");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<ReadBookmark> ReadBookmarkAsync() => BridgeConnector.OnResult<ReadBookmark>("clipboard-readBookmark", "clipboard-readBookmark-Completed");
 
         /// <summary>
         /// Writes the title and url into the clipboard as a bookmark.
@@ -162,7 +107,7 @@ namespace ElectronNET.API
         /// <param name="type"></param>
         public void WriteBookmark(string title, string url, string type = "")
         {
-            BridgeConnector.Socket.Emit("clipboard-writeBookmark", title, url, type);
+            BridgeConnector.Emit("clipboard-writeBookmark", title, url, type);
         }
 
         /// <summary>
@@ -171,21 +116,7 @@ namespace ElectronNET.API
         /// find pasteboard whenever the application is activated.
         /// </summary>
         /// <returns></returns>
-        public Task<string> ReadFindTextAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("clipboard-readFindText-Completed", (text) =>
-            {
-                BridgeConnector.Socket.Off("clipboard-readFindText-Completed");
-
-                taskCompletionSource.SetResult(text.ToString());
-            });
-
-            BridgeConnector.Socket.Emit("clipboard-readFindText");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<string> ReadFindTextAsync() => BridgeConnector.OnResult<string>("clipboard-readFindText", "clipboard-readFindText-Completed");
 
         /// <summary>
         /// macOS: Writes the text into the find pasteboard as plain text. This method uses 
@@ -194,7 +125,7 @@ namespace ElectronNET.API
         /// <param name="text"></param>
         public void WriteFindText(string text)
         {
-            BridgeConnector.Socket.Emit("clipboard-writeFindText", text);
+            BridgeConnector.Emit("clipboard-writeFindText", text);
         }
 
         /// <summary>
@@ -203,7 +134,7 @@ namespace ElectronNET.API
         /// <param name="type"></param>
         public void Clear(string type = "")
         {
-            BridgeConnector.Socket.Emit("clipboard-clear", type);
+            BridgeConnector.Emit("clipboard-clear", type);
         }
 
         /// <summary>
@@ -211,21 +142,7 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="type"></param>
         /// <returns></returns>
-        public Task<string[]> AvailableFormatsAsync(string type = "")
-        {
-            var taskCompletionSource = new TaskCompletionSource<string[]>();
-
-            BridgeConnector.Socket.On("clipboard-availableFormats-Completed", (formats) =>
-            {
-                BridgeConnector.Socket.Off("clipboard-availableFormats-Completed");
-
-                taskCompletionSource.SetResult(((JArray)formats).ToObject<string[]>());
-            });
-
-            BridgeConnector.Socket.Emit("clipboard-availableFormats", type);
-
-            return taskCompletionSource.Task;
-        }
+        public Task<string[]> AvailableFormatsAsync(string type = "") => BridgeConnector.OnResult<string[]>("clipboard-availableFormats", "clipboard-availableFormats-Completed", type);
 
         /// <summary>
         /// Writes data to the clipboard.
@@ -234,7 +151,7 @@ namespace ElectronNET.API
         /// <param name="type"></param>
         public void Write(Data data, string type = "")
         {
-            BridgeConnector.Socket.Emit("clipboard-write", JObject.FromObject(data, _jsonSerializer), type);
+            BridgeConnector.Emit("clipboard-write", data, type);
         }
 
         /// <summary>
@@ -242,24 +159,7 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="type"></param>
         /// <returns></returns>
-        public Task<NativeImage> ReadImageAsync(string type = "")
-        {
-            var taskCompletionSource = new TaskCompletionSource<NativeImage>();
-
-            BridgeConnector.Socket.On("clipboard-readImage-Completed", (image) =>
-            {
-                BridgeConnector.Socket.Off("clipboard-readImage-Completed");
-
-                var nativeImage = ((JObject)image).ToObject<NativeImage>();
-
-                taskCompletionSource.SetResult(nativeImage);
-                
-            });
-
-            BridgeConnector.Socket.Emit("clipboard-readImage", type);
-            
-            return taskCompletionSource.Task;
-        }
+        public Task<NativeImage> ReadImageAsync(string type = "") => BridgeConnector.OnResult<NativeImage>("clipboard-readImage", "clipboard-readImage-Completed", type);
         
         /// <summary>
         /// Writes an image to the clipboard.
@@ -268,14 +168,7 @@ namespace ElectronNET.API
         /// <param name="type"></param>
         public void WriteImage(NativeImage image, string type = "")
         {
-            BridgeConnector.Socket.Emit("clipboard-writeImage", JsonConvert.SerializeObject(image), type);
+            BridgeConnector.Emit("clipboard-writeImage", JsonConvert.SerializeObject(image), type);
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
     }
 }

ElectronNET.API/CommandLine.cs

@@ -43,7 +43,7 @@ namespace ElectronNET.API
         /// </remarks>
         public void AppendSwitch(string the_switch, string value = "")
         {
-            BridgeConnector.Socket.Emit("appCommandLineAppendSwitch", the_switch, value);
+            BridgeConnector.Emit("appCommandLineAppendSwitch", the_switch, value);
         }
 
         /// <summary>
@@ -57,7 +57,7 @@ namespace ElectronNET.API
         /// </remarks>
         public void AppendArgument(string value)
         {
-            BridgeConnector.Socket.Emit("appCommandLineAppendArgument", value);
+            BridgeConnector.Emit("appCommandLineAppendArgument", value);
         }
 
         /// <summary>
@@ -66,24 +66,7 @@ namespace ElectronNET.API
         /// <param name="switchName">A command-line switch</param>
         /// <param name="cancellationToken"></param>
         /// <returns>Whether the command-line switch is present.</returns>
-        public async Task<bool> HasSwitchAsync(string switchName, CancellationToken cancellationToken = default(CancellationToken)) 
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
-            {
-                BridgeConnector.Socket.On("appCommandLineHasSwitchCompleted", (result) =>
-                {
-                    BridgeConnector.Socket.Off("appCommandLineHasSwitchCompleted");
-                    taskCompletionSource.SetResult((bool)result);
-                });
-
-                BridgeConnector.Socket.Emit("appCommandLineHasSwitch", switchName);
-
-                return await taskCompletionSource.Task.ConfigureAwait(false);
-            }
-        }
+        public Task<bool> HasSwitchAsync(string switchName, CancellationToken cancellationToken = default) => BridgeConnector.OnResult<bool>("appCommandLineHasSwitch", "appCommandLineHasSwitchCompleted", cancellationToken, switchName);
 
         /// <summary>
         /// The command-line switch value.
@@ -94,23 +77,6 @@ namespace ElectronNET.API
         /// <remarks>
         /// Note: When the switch is not present or has no value, it returns empty string.
         /// </remarks>
-        public async Task<string> GetSwitchValueAsync(string switchName, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            var taskCompletionSource = new TaskCompletionSource<string>();
-            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
-            {
-                BridgeConnector.Socket.On("appCommandLineGetSwitchValueCompleted", (result) =>
-                {
-                    BridgeConnector.Socket.Off("appCommandLineGetSwitchValueCompleted");
-                    taskCompletionSource.SetResult((string)result);
-                });
-
-                BridgeConnector.Socket.Emit("appCommandLineGetSwitchValue", switchName);
-
-                return await taskCompletionSource.Task.ConfigureAwait(false);
-            }
-        }
+        public Task<string> GetSwitchValueAsync(string switchName, CancellationToken cancellationToken = default) => BridgeConnector.OnResult<string>("appCommandLineGetSwitchValue", "appCommandLineGetSwitchValueCompleted", cancellationToken, switchName);
     }
 }

ElectronNET.API/Cookies.cs

@@ -34,15 +34,12 @@ namespace ElectronNET.API
             {
                 if (_changed == null)
                 {
-                    BridgeConnector.Socket.On("webContents-session-cookies-changed" + Id, (args) =>
+                    BridgeConnector.On<CookieRemovedResponse>("webContents-session-cookies-changed" + Id, (args) =>
                     {
-                        Cookie cookie = ((JArray)args)[0].ToObject<Cookie>();
-                        CookieChangedCause cause = ((JArray)args)[1].ToObject<CookieChangedCause>();
-                        bool removed = ((JArray)args)[2].ToObject<bool>();
-                        _changed(cookie, cause, removed);
+                        _changed(args.cookie, args.cause, args.removed);
                     });
 
-                    BridgeConnector.Socket.Emit("register-webContents-session-cookies-changed", Id);
+                    BridgeConnector.Emit("register-webContents-session-cookies-changed", Id);
                 }
                 _changed += value;
             }
@@ -51,7 +48,7 @@ namespace ElectronNET.API
                 _changed -= value;
 
                 if (_changed == null)
-                    BridgeConnector.Socket.Off("webContents-session-cookies-changed" + Id);
+                    BridgeConnector.Off("webContents-session-cookies-changed" + Id);
             }
         }
 
@@ -65,18 +62,16 @@ namespace ElectronNET.API
         /// <returns>A task which resolves an array of cookie objects.</returns>
         public Task<Cookie[]> GetAsync(CookieFilter filter)
         {
-            var taskCompletionSource = new TaskCompletionSource<Cookie[]>();
+            var taskCompletionSource = new TaskCompletionSource<Cookie[]>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-cookies-get-completed" + guid, (cookies) =>
+            BridgeConnector.On<Cookie[]>("webContents-session-cookies-get-completed" + guid, (cookies) =>
             {
-                Cookie[] result = ((JArray)cookies).ToObject<Cookie[]>();
-
-                BridgeConnector.Socket.Off("webContents-session-cookies-get-completed" + guid);
-                taskCompletionSource.SetResult(result);
+                BridgeConnector.Off("webContents-session-cookies-get-completed" + guid);
+                taskCompletionSource.SetResult(cookies);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-cookies-get", Id, JObject.FromObject(filter, _jsonSerializer), guid);
+            BridgeConnector.Emit("webContents-session-cookies-get", Id, filter, guid);
 
             return taskCompletionSource.Task;
         }
@@ -88,16 +83,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task SetAsync(CookieDetails details)
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-cookies-set-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-cookies-set-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-cookies-set-completed" + guid);
+                BridgeConnector.Off("webContents-session-cookies-set-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-cookies-set", Id, JObject.FromObject(details, _jsonSerializer), guid);
+            BridgeConnector.Emit("webContents-session-cookies-set", Id, details, guid);
 
             return taskCompletionSource.Task;
         }
@@ -110,16 +105,16 @@ namespace ElectronNET.API
         /// <returns>A task which resolves when the cookie has been removed</returns>
         public Task RemoveAsync(string url, string name)
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-cookies-remove-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-cookies-remove-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-cookies-remove-completed" + guid);
+                BridgeConnector.Off("webContents-session-cookies-remove-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-cookies-remove", Id, url, name, guid);
+            BridgeConnector.Emit("webContents-session-cookies-remove", Id, url, name, guid);
 
             return taskCompletionSource.Task;
         }
@@ -130,25 +125,18 @@ namespace ElectronNET.API
         /// <returns>A task which resolves when the cookie store has been flushed</returns>
         public Task FlushStoreAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-cookies-flushStore-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-cookies-flushStore-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-cookies-flushStore-completed" + guid);
+                BridgeConnector.Off("webContents-session-cookies-flushStore-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-cookies-flushStore", Id, guid);
+            BridgeConnector.Emit("webContents-session-cookies-flushStore", Id, guid);
 
             return taskCompletionSource.Task;
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
     }
 }

ElectronNET.API/Dialog.cs

@@ -48,26 +48,23 @@ namespace ElectronNET.API
         /// <returns>An array of file paths chosen by the user</returns>
         public Task<string[]> ShowOpenDialogAsync(BrowserWindow browserWindow, OpenDialogOptions options)
         {
-            var taskCompletionSource = new TaskCompletionSource<string[]>();
+            var taskCompletionSource = new TaskCompletionSource<string[]>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("showOpenDialogComplete" + guid, (filePaths) =>
+            BridgeConnector.On<string[]>("showOpenDialogComplete" + guid, (filePaths) =>
             {
-                BridgeConnector.Socket.Off("showOpenDialogComplete" + guid);
+                BridgeConnector.Off("showOpenDialogComplete" + guid);
 
-                var result = ((JArray)filePaths).ToObject<string[]>();
                 var list = new List<string>();
-                foreach (var item in result)
+
+                foreach (var item in filePaths)
                 {
                     list.Add(HttpUtility.UrlDecode(item));
                 }
                 taskCompletionSource.SetResult(list.ToArray());
             });
 
-
-            BridgeConnector.Socket.Emit("showOpenDialog",
-            JObject.FromObject(browserWindow, _jsonSerializer),
-            JObject.FromObject(options, _jsonSerializer), guid);
+            BridgeConnector.Emit("showOpenDialog", browserWindow, options, guid);
 
             return taskCompletionSource.Task;
         }
@@ -80,20 +77,17 @@ namespace ElectronNET.API
         /// <returns>Returns String, the path of the file chosen by the user, if a callback is provided it returns an empty string.</returns>
         public Task<string> ShowSaveDialogAsync(BrowserWindow browserWindow, SaveDialogOptions options)
         {
-            var taskCompletionSource = new TaskCompletionSource<string>();
+            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("showSaveDialogComplete" + guid, (filename) =>
+            BridgeConnector.On<string>("showSaveDialogComplete" + guid, (filename) =>
             {
-                BridgeConnector.Socket.Off("showSaveDialogComplete" + guid);
+                BridgeConnector.Off("showSaveDialogComplete" + guid);
 
-                taskCompletionSource.SetResult(filename.ToString());
+                taskCompletionSource.SetResult(filename);
             });
 
-            BridgeConnector.Socket.Emit("showSaveDialog",
-            JObject.FromObject(browserWindow, _jsonSerializer),
-            JObject.FromObject(options, _jsonSerializer),
-            guid);
+            BridgeConnector.Emit("showSaveDialog", browserWindow, options, guid);
 
             return taskCompletionSource.Task;
         }
@@ -149,32 +143,27 @@ namespace ElectronNET.API
         /// <returns>The API call will be asynchronous and the result will be passed via MessageBoxResult.</returns>
         public Task<MessageBoxResult> ShowMessageBoxAsync(BrowserWindow browserWindow, MessageBoxOptions messageBoxOptions)
         {
-            var taskCompletionSource = new TaskCompletionSource<MessageBoxResult>();
+            var taskCompletionSource = new TaskCompletionSource<MessageBoxResult>(TaskCreationOptions.RunContinuationsAsynchronously);
             var guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("showMessageBoxComplete" + guid, (args) =>
+            BridgeConnector.On<MessageBoxResponse>("showMessageBoxComplete" + guid, (args) =>
             {
-                BridgeConnector.Socket.Off("showMessageBoxComplete" + guid);
-
-                var result = ((JArray)args);
+                BridgeConnector.Off("showMessageBoxComplete" + guid);
 
                 taskCompletionSource.SetResult(new MessageBoxResult
                 {
-                    Response = (int)result.First,
-                    CheckboxChecked = (bool)result.Last
+                    Response = args.response,
+                    CheckboxChecked = args.@checked
                 });
 
             });
 
             if (browserWindow == null)
             {
-                BridgeConnector.Socket.Emit("showMessageBox", JObject.FromObject(messageBoxOptions, _jsonSerializer), guid);
+                BridgeConnector.Emit("showMessageBox", messageBoxOptions, guid);
             } else
             {
-                BridgeConnector.Socket.Emit("showMessageBox", 
-                    JObject.FromObject(browserWindow, _jsonSerializer),
-                    JObject.FromObject(messageBoxOptions, _jsonSerializer),
-                    guid);
+                BridgeConnector.Emit("showMessageBox", browserWindow , messageBoxOptions, guid);
             }
 
             return taskCompletionSource.Task;
@@ -192,7 +181,7 @@ namespace ElectronNET.API
         /// <param name="content">The text content to display in the error box.</param>
         public void ShowErrorBox(string title, string content)
         {
-            BridgeConnector.Socket.Emit("showErrorBox", title, content);
+            BridgeConnector.Emit("showErrorBox", title, content);
         }
 
         /// <summary>
@@ -217,28 +206,18 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task ShowCertificateTrustDialogAsync(BrowserWindow browserWindow, CertificateTrustDialogOptions options)
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("showCertificateTrustDialogComplete" + guid, () =>
+            BridgeConnector.On("showCertificateTrustDialogComplete" + guid, () =>
             {
-                BridgeConnector.Socket.Off("showCertificateTrustDialogComplete" + guid);
+                BridgeConnector.Off("showCertificateTrustDialogComplete" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("showCertificateTrustDialog",
-                JObject.FromObject(browserWindow, _jsonSerializer),
-                JObject.FromObject(options, _jsonSerializer),
-                guid);
+            BridgeConnector.Emit("showCertificateTrustDialog", browserWindow, options, guid);
 
             return taskCompletionSource.Task;
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
     }
 }

ElectronNET.API/Dock.cs

@@ -50,24 +50,11 @@ namespace ElectronNET.API
         /// <param name="type">Can be critical or informational. The default is informational.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Return an ID representing the request.</returns>
-        public async Task<int> BounceAsync(DockBounceType type, CancellationToken cancellationToken = default)
+        public Task<int> BounceAsync(DockBounceType type, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            var taskCompletionSource = new TaskCompletionSource<int>();
-            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
-            {
-                BridgeConnector.Socket.On("dock-bounce-completed", (id) =>
-                {
-                    BridgeConnector.Socket.Off("dock-bounce-completed");
-                    taskCompletionSource.SetResult((int) id);
-                });
-
-                BridgeConnector.Socket.Emit("dock-bounce", type.GetDescription());
-
-                return await taskCompletionSource.Task
-                    .ConfigureAwait(false);
-            }
+            return BridgeConnector.OnResult<int>("dock-bounce", "dock-bounce-completed", cancellationToken, type.GetDescription());
         }
 
         /// <summary>
@@ -76,7 +63,7 @@ namespace ElectronNET.API
         /// <param name="id">Id of the request.</param>
         public void CancelBounce(int id)
         {
-            BridgeConnector.Socket.Emit("dock-cancelBounce", id);
+            BridgeConnector.Emit("dock-cancelBounce", id);
         }
 
         /// <summary>
@@ -85,7 +72,7 @@ namespace ElectronNET.API
         /// <param name="filePath"></param>
         public void DownloadFinished(string filePath)
         {
-            BridgeConnector.Socket.Emit("dock-downloadFinished", filePath);
+            BridgeConnector.Emit("dock-downloadFinished", filePath);
         }
 
         /// <summary>
@@ -94,7 +81,7 @@ namespace ElectronNET.API
         /// <param name="text"></param>
         public void SetBadge(string text)
         {
-            BridgeConnector.Socket.Emit("dock-setBadge", text);
+            BridgeConnector.Emit("dock-setBadge", text);
         }
 
         /// <summary>
@@ -102,24 +89,10 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>The badge string of the dock.</returns>
-        public async Task<string> GetBadgeAsync(CancellationToken cancellationToken = default)
+        public Task<string> GetBadgeAsync(CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
-
-            var taskCompletionSource = new TaskCompletionSource<string>();
-            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
-            {
-                BridgeConnector.Socket.On("dock-getBadge-completed", (text) =>
-                {
-                    BridgeConnector.Socket.Off("dock-getBadge-completed");
-                    taskCompletionSource.SetResult((string) text);
-                });
-
-                BridgeConnector.Socket.Emit("dock-getBadge");
-
-                return await taskCompletionSource.Task
-                    .ConfigureAwait(false);
-            }
+            return BridgeConnector.OnResult<string>("dock-getBadge", "dock-getBadge-completed", cancellationToken);
         }
 
         /// <summary>
@@ -127,7 +100,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Hide()
         {
-            BridgeConnector.Socket.Emit("dock-hide");
+            BridgeConnector.Emit("dock-hide");
         }
 
         /// <summary>
@@ -135,7 +108,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Show()
         {
-            BridgeConnector.Socket.Emit("dock-show");
+            BridgeConnector.Emit("dock-show");
         }
 
         /// <summary>
@@ -144,24 +117,10 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Whether the dock icon is visible.</returns>
-        public async Task<bool> IsVisibleAsync(CancellationToken cancellationToken = default)
+        public Task<bool> IsVisibleAsync(CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
-
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
-            {
-                BridgeConnector.Socket.On("dock-isVisible-completed", (isVisible) =>
-                {
-                    BridgeConnector.Socket.Off("dock-isVisible-completed");
-                    taskCompletionSource.SetResult((bool) isVisible);
-                });
-
-                BridgeConnector.Socket.Emit("dock-isVisible");
-
-                return await taskCompletionSource.Task
-                    .ConfigureAwait(false);
-            }
+            return BridgeConnector.OnResult<bool>("dock-isVisible", "dock-isVisible-completed", cancellationToken);
         }
 
         /// <summary>
@@ -179,40 +138,21 @@ namespace ElectronNET.API
         public void SetMenu(MenuItem[] menuItems)
         {
             menuItems.AddMenuItemsId();
-            BridgeConnector.Socket.Emit("dock-setMenu", JArray.FromObject(menuItems, _jsonSerializer));
+            BridgeConnector.Emit("dock-setMenu", JArray.FromObject(menuItems, _jsonSerializer));
             _items.AddRange(menuItems);
 
-            BridgeConnector.Socket.Off("dockMenuItemClicked");
-            BridgeConnector.Socket.On("dockMenuItemClicked", (id) => {
-                MenuItem menuItem = _items.GetMenuItem(id.ToString());
+            BridgeConnector.Off("dockMenuItemClicked");
+            BridgeConnector.On<string>("dockMenuItemClicked", (id) => {
+                MenuItem menuItem = _items.GetMenuItem(id);
                 menuItem?.Click();
             });
-           
         }
 
         /// <summary>
         /// TODO: Menu (macOS) still to be implemented
         /// Gets the application's dock menu.
         /// </summary>
-        public async Task<Menu> GetMenu(CancellationToken cancellationToken = default)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            var taskCompletionSource = new TaskCompletionSource<Menu>();
-            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
-            {
-                BridgeConnector.Socket.On("dock-getMenu-completed", (menu) =>
-                {
-                    BridgeConnector.Socket.Off("dock-getMenu-completed");
-                    taskCompletionSource.SetResult(((JObject)menu).ToObject<Menu>());
-                });
-
-                BridgeConnector.Socket.Emit("dock-getMenu");
-
-                return await taskCompletionSource.Task
-                    .ConfigureAwait(false);
-            }
-        }
+        public Task<Menu> GetMenu(CancellationToken cancellationToken = default) => BridgeConnector.OnResult<Menu>("dock-getMenu", "dock-getMenu-completed", cancellationToken);
 
         /// <summary>
         /// Sets the image associated with this dock icon.
@@ -220,10 +160,10 @@ namespace ElectronNET.API
         /// <param name="image"></param>
         public void SetIcon(string image)
         {
-            BridgeConnector.Socket.Emit("dock-setIcon", image);
+            BridgeConnector.Emit("dock-setIcon", image);
         }
 
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        private static readonly JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
             NullValueHandling = NullValueHandling.Ignore

ElectronNET.API/ElectronNET.API.csproj

@@ -5,14 +5,14 @@
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageOutputPath>..\artifacts</PackageOutputPath>
     <PackageId>ElectronNET.API</PackageId>
-    <Authors>Gregor Biswanger, Robert Muehsig</Authors>
+    <Authors>Gregor Biswanger, Robert Muehsig, Rafael Oliveira</Authors>
     <Company />
     <Product>Electron.NET</Product>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <PackageProjectUrl>https://github.com/ElectronNET/Electron.NET/</PackageProjectUrl>
+    <PackageProjectUrl>https://github.com/ElectronNet/Electron.NET/</PackageProjectUrl>
     <Description>Building cross platform electron based desktop apps with .NET Core and ASP.NET Core.
 This package contains the API to access the "native" electron API.</Description>
-    <RepositoryUrl>https://github.com/ElectronNET/Electron.NET/</RepositoryUrl>
+    <RepositoryUrl>https://github.com/ElectronNet/Electron.NET/</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
     <PackageTags>electron aspnetcore</PackageTags>
@@ -40,8 +40,10 @@ This package contains the API to access the "native" electron API.</Description>
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="SocketIoClientDotNet" Version="1.0.5" />
-    <PackageReference Include="System.Drawing.Common" Version="5.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+    <PackageReference Include="SocketIOClient" Version="2.3.1" />
+    <PackageReference Include="SocketIOClient.Newtonsoft.Json" Version="2.3.1" />
+    <PackageReference Include="System.Drawing.Common" Version="5.0.2" />
   </ItemGroup>
 
 </Project>

ElectronNET.API/Entities/CookieChangedCause.cs

@@ -1,7 +1,9 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
-namespace ElectronNET.API.Entities {
+namespace ElectronNET.API.Entities
+{
+
     /// <summary>
     /// The cause of the change 
     /// </summary>

ElectronNET.API/Entities/CookieRemovedResponse.cs

@@ -0,0 +1,10 @@
+namespace ElectronNET.API.Entities
+{
+    public class CookieRemovedResponse
+    {
+        public Cookie cookie {get;set;}
+
+        public CookieChangedCause cause { get; set; }
+        public bool removed { get; set; }
+    }
+}

ElectronNET.API/Entities/Display.cs

@@ -1,5 +1,10 @@
 namespace ElectronNET.API.Entities
 {
+    public class DisplayChanged
+    {
+        public Display display { get; set; }
+        public string[] metrics { get; set; }
+    }
     /// <summary>
     /// 
     /// </summary>

ElectronNET.API/Entities/JumpListSettings.cs

@@ -1,8 +1,5 @@
 namespace ElectronNET.API.Entities
 {
-    /// <summary>
-    /// 
-    /// </summary>
     public class JumpListSettings
     {
         /// <summary>

ElectronNET.API/Entities/MessageBoxResult.cs

@@ -1,5 +1,11 @@
 namespace ElectronNET.API.Entities
 {
+    internal class MessageBoxResponse
+    {
+        public int response { get; set; }
+        public bool @checked { get; set; }
+    }
+
     /// <summary>
     /// 
     /// </summary>

ElectronNET.API/Entities/ReleaseNoteInfo.cs

@@ -1,18 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class ReleaseNoteInfo
-    {
-        /// <summary>
-        /// The version.
-        /// </summary>
-        public string Version { get; set; }
-
-        /// <summary>
-        /// The note.
-        /// </summary>
-        public string Note { get; set; }
-    }
-}

ElectronNET.API/Entities/SecondInstanceResponse.cs

@@ -0,0 +1,9 @@
+namespace ElectronNET.API.Entities
+{
+    public class SecondInstanceResponse
+    {
+        public string[] args { get; set; }
+
+        public string workingDirectory  { get;set;}
+    }
+}

ElectronNET.API/Entities/TrayClickEventArgs.cs

@@ -1,5 +1,6 @@
 namespace ElectronNET.API
 {
+
     /// <summary>
     /// 
     /// </summary>

ElectronNET.API/Entities/TrayClickEventResponse.cs

@@ -0,0 +1,8 @@
+namespace ElectronNET.API.Entities
+{
+    public class TrayClickEventResponse
+    {
+        public TrayClickEventArgs eventArgs { get; set; }
+        public Rectangle bounds { get; set; }
+    }
+}

ElectronNET.API/Entities/UpdateInfo.cs

@@ -23,7 +23,7 @@
         /// <summary>
         /// The release notes.
         /// </summary>
-        public ReleaseNoteInfo[] ReleaseNotes { get; set; } = new ReleaseNoteInfo[0];
+        public string ReleaseNotes { get; set; }
 
         /// <summary>
         /// 

ElectronNET.API/Entities/WebPreferences.cs

@@ -184,6 +184,7 @@ namespace ElectronNET.API.Entities
         /// can access this context in the dev tools by selecting the 'Electron Isolated
         /// Context' entry in the combo box at the top of the Console tab. This option is
         /// currently experimental and may change or be removed in future Electron releases.
+        /// Default value is false.
         /// </summary>
         [DefaultValue(false)]
         public bool ContextIsolation { get; set; } = false;

ElectronNET.API/Events.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Globalization;
-using Quobject.EngineIoClientDotNet.ComponentEmitter;
 
 namespace ElectronNET.API
 {
@@ -42,8 +41,8 @@ namespace ElectronNET.API
         /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
         /// <param name="eventName">The name of the event</param>
         /// <param name="fn">The event handler</param>
-        public void On(string moduleName, string eventName, Action fn)
-            => On(moduleName, eventName, new ListenerImpl(fn));
+        public void On(string moduleName, string eventName, Action fn) => On(moduleName, eventName, _ => fn());
+
 
         /// <summary>
         /// Subscribe to an unmapped electron event.
@@ -52,21 +51,12 @@ namespace ElectronNET.API
         /// <param name="eventName">The name of the event</param>
         /// <param name="fn">The event handler</param>
         public void On(string moduleName, string eventName, Action<object> fn)
-            => On(moduleName, eventName, new ListenerImpl(fn));
-
-        /// <summary>
-        /// Subscribe to an unmapped electron event.
-        /// </summary>
-        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
-        /// <param name="eventName">The name of the event</param>
-        /// <param name="fn">The event handler</param>
-        private void On(string moduleName, string eventName, IListener fn)
         {
             var listener = $"{moduleName}{_ti.ToTitleCase(eventName)}Completed";
             var subscriber = $"register-{moduleName}-on-event";
             
-            BridgeConnector.Socket.On(listener, fn);
-            BridgeConnector.Socket.Emit(subscriber, eventName, listener);
+            BridgeConnector.On(listener, fn);
+            BridgeConnector.Emit(subscriber, eventName, listener);
         }
 
         /// <summary>
@@ -75,8 +65,7 @@ namespace ElectronNET.API
         /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
         /// <param name="eventName">The name of the event</param>
         /// <param name="fn">The event handler</param>
-        public void Once(string moduleName, string eventName, Action fn)
-            => Once(moduleName, eventName, new ListenerImpl(fn));
+        public void Once(string moduleName, string eventName, Action fn) => Once(moduleName, eventName, _ => fn());
 
         /// <summary>
         /// Subscribe to an unmapped electron event.
@@ -85,21 +74,11 @@ namespace ElectronNET.API
         /// <param name="eventName">The name of the event</param>
         /// <param name="fn">The event handler</param>
         public void Once(string moduleName, string eventName, Action<object> fn)
-            => Once(moduleName, eventName, new ListenerImpl(fn));
-
-        /// <summary>
-        /// Subscribe to an unmapped electron event.
-        /// </summary>
-        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
-        /// <param name="eventName">The name of the event</param>
-        /// <param name="fn">The event handler</param>
-        private void Once(string moduleName, string eventName, IListener fn)
         {
             var listener = $"{moduleName}{_ti.ToTitleCase(eventName)}Completed";
             var subscriber = $"register-{moduleName}-once-event";
-            BridgeConnector.Socket.Once(listener, fn);
-            BridgeConnector.Socket.Emit(subscriber, eventName, listener);
+            BridgeConnector.Once(listener, fn);
+            BridgeConnector.Emit(subscriber, eventName, listener);
         }
-
     }
 }

ElectronNET.API/GlobalShortcut.cs

@@ -49,16 +49,16 @@ namespace ElectronNET.API
             {
                 _shortcuts.Add(accelerator, function);
 
-                BridgeConnector.Socket.Off("globalShortcut-pressed");
-                BridgeConnector.Socket.On("globalShortcut-pressed", (shortcut) =>
+                BridgeConnector.Off("globalShortcut-pressed");
+                BridgeConnector.On<string>("globalShortcut-pressed", (shortcut) =>
                 {
-                    if (_shortcuts.ContainsKey(shortcut.ToString()))
+                    if (_shortcuts.ContainsKey(shortcut))
                     {
                         _shortcuts[shortcut.ToString()]();
                     }
                 });
 
-                BridgeConnector.Socket.Emit("globalShortcut-register", accelerator);
+                BridgeConnector.Emit("globalShortcut-register", accelerator);
             }
         }
 
@@ -68,21 +68,8 @@ namespace ElectronNET.API
         /// since they don’t want applications to fight for global shortcuts.
         /// </summary>
         /// <returns>Whether this application has registered accelerator.</returns>
-        public Task<bool> IsRegisteredAsync(string accelerator)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
+        public Task<bool> IsRegisteredAsync(string accelerator) => BridgeConnector.OnResult<bool>("globalShortcut-isRegistered", "globalShortcut-isRegisteredCompleted", accelerator);
 
-            BridgeConnector.Socket.On("globalShortcut-isRegisteredCompleted", (isRegistered) =>
-            {
-                BridgeConnector.Socket.Off("globalShortcut-isRegisteredCompleted");
-
-                taskCompletionSource.SetResult((bool)isRegistered);
-            });
-
-            BridgeConnector.Socket.Emit("globalShortcut-isRegistered", accelerator);
-
-            return taskCompletionSource.Task;
-        }
 
         /// <summary>
         /// Unregisters the global shortcut of accelerator.
@@ -90,7 +77,7 @@ namespace ElectronNET.API
         public void Unregister(string accelerator)
         {
             _shortcuts.Remove(accelerator);
-            BridgeConnector.Socket.Emit("globalShortcut-unregister", accelerator);
+            BridgeConnector.Emit("globalShortcut-unregister", accelerator);
         }
 
         /// <summary>
@@ -99,7 +86,7 @@ namespace ElectronNET.API
         public void UnregisterAll()
         {
             _shortcuts.Clear();
-            BridgeConnector.Socket.Emit("globalShortcut-unregisterAll");
+            BridgeConnector.Emit("globalShortcut-unregisterAll");
         }
     }
 }

ElectronNET.API/HostHook.cs

@@ -47,13 +47,13 @@ namespace ElectronNET.API
         /// <param name="arguments">Optional parameters.</param>
         public void Call(string socketEventName, params dynamic[] arguments)
         {
-            BridgeConnector.Socket.On(socketEventName + "Error" + oneCallguid, (result) =>
+            BridgeConnector.On<string>(socketEventName + "Error" + oneCallguid, (result) =>
             {
-                BridgeConnector.Socket.Off(socketEventName + "Error" + oneCallguid);
-                Electron.Dialog.ShowErrorBox("Host Hook Exception", result.ToString());
+                BridgeConnector.Off(socketEventName + "Error" + oneCallguid);
+                Electron.Dialog.ShowErrorBox("Host Hook Exception", result);
             });
 
-            BridgeConnector.Socket.Emit(socketEventName, arguments, oneCallguid);
+            BridgeConnector.Emit(socketEventName, arguments, oneCallguid);
         }
 
         /// <summary>
@@ -65,64 +65,26 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<T> CallAsync<T>(string socketEventName, params dynamic[] arguments)
         {
-            var taskCompletionSource = new TaskCompletionSource<T>();
+            var taskCompletionSource = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On(socketEventName + "Error" + guid, (result) =>
+            BridgeConnector.On<string>(socketEventName + "Error" + guid, (result) =>
             {
-                BridgeConnector.Socket.Off(socketEventName + "Error" + guid);
-                Electron.Dialog.ShowErrorBox("Host Hook Exception", result.ToString());
+                BridgeConnector.Off(socketEventName + "Error" + guid);
+                Electron.Dialog.ShowErrorBox("Host Hook Exception", result);
                 taskCompletionSource.SetException(new Exception($"Host Hook Exception {result}"));
             });
 
-            BridgeConnector.Socket.On(socketEventName + "Complete" + guid, (result) =>
+            BridgeConnector.On<T>(socketEventName + "Complete" + guid, (result) =>
             {
-                BridgeConnector.Socket.Off(socketEventName + "Error" + guid);
-                BridgeConnector.Socket.Off(socketEventName + "Complete" + guid);
-                T data = default;
-
-                try
-                {
-                    if (result.GetType().IsValueType || result is string)
-                    {
-                        data = (T)result;
-                    }
-                    else
-                    {
-                        var token = JToken.Parse(result.ToString());
-                        if (token is JArray)
-                        {
-                            data = token.ToObject<T>();
-                        }
-                        else if (token is JObject)
-                        {
-                            data = token.ToObject<T>();
-                        }
-                        else
-                        {
-                            data = (T)result;
-                        }
-                    }
-                }
-                catch (Exception exception)
-                {
-                    taskCompletionSource.SetException(exception);
-                    //throw new InvalidCastException("Return value does not match with the generic type.", exception);
-                }
-
-                taskCompletionSource.SetResult(data);
+                BridgeConnector.Off(socketEventName + "Error" + guid);
+                BridgeConnector.Off(socketEventName + "Complete" + guid);
+                taskCompletionSource.SetResult(result);
             });
 
-            BridgeConnector.Socket.Emit(socketEventName, arguments, guid);
+            BridgeConnector.Emit(socketEventName, arguments, guid);
 
             return taskCompletionSource.Task;
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
     }
 }

ElectronNET.API/IpcMain.cs

@@ -45,11 +45,11 @@ namespace ElectronNET.API
         /// <param name="listener">Callback Method.</param>
         public void On(string channel, Action<object> listener)
         {
-            BridgeConnector.Socket.Emit("registerIpcMainChannel", channel);
-            BridgeConnector.Socket.Off(channel);
-            BridgeConnector.Socket.On(channel, (args) => 
+            BridgeConnector.Emit("registerIpcMainChannel", channel);
+            BridgeConnector.Off(channel);
+            BridgeConnector.On<object[]>(channel, (args) => 
             {
-                List<object> objectArray = FormatArguments(args);
+                var objectArray = FormatArguments(args);
 
                 if(objectArray.Count == 1)
                 {
@@ -62,20 +62,9 @@ namespace ElectronNET.API
             });
         }
 
-        private List<object> FormatArguments(object args)
+        private List<object> FormatArguments(object[] objectArray)
         {
-            List<object> objectArray = ((JArray)args).ToObject<object[]>().ToList();
-
-            for (int index = 0; index < objectArray.Count; index++)
-            {
-                var item = objectArray[index];
-                if (item == null)
-                {
-                    objectArray.Remove(item);
-                }
-            }
-
-            return objectArray;
+            return objectArray.Where(o => o is object).ToList();
         }
 
         /// <summary>
@@ -89,9 +78,9 @@ namespace ElectronNET.API
         /// <param name="listener"></param>
         public void OnSync(string channel, Func<object, object> listener)
         {
-            BridgeConnector.Socket.Emit("registerSyncIpcMainChannel", channel);
-            BridgeConnector.Socket.On(channel, (args) => {
-                List<object> objectArray = FormatArguments(args);
+            BridgeConnector.Emit("registerSyncIpcMainChannel", channel);
+            BridgeConnector.On<object[]>(channel, (args) => {
+                var objectArray = FormatArguments(args);
                 object parameter;
                 if (objectArray.Count == 1)
                 {
@@ -103,7 +92,7 @@ namespace ElectronNET.API
                 }
 
                 var result = listener(parameter);
-                BridgeConnector.Socket.Emit(channel + "Sync", result);
+                BridgeConnector.Emit(channel + "Sync", result);
             });
         }
 
@@ -115,10 +104,10 @@ namespace ElectronNET.API
         /// <param name="listener">Callback Method.</param>
         public void Once(string channel, Action<object> listener)
         {
-            BridgeConnector.Socket.Emit("registerOnceIpcMainChannel", channel);
-            BridgeConnector.Socket.On(channel, (args) =>
+            BridgeConnector.Emit("registerOnceIpcMainChannel", channel);
+            BridgeConnector.On<object[]>(channel, (args) =>
             {
-                List<object> objectArray = FormatArguments(args);
+                var objectArray = FormatArguments(args);
 
                 if (objectArray.Count == 1)
                 {
@@ -137,7 +126,7 @@ namespace ElectronNET.API
         /// <param name="channel">Channelname.</param>
         public void RemoveAllListeners(string channel)
         {
-            BridgeConnector.Socket.Emit("removeAllListenersIpcMainChannel", channel);
+            BridgeConnector.Emit("removeAllListenersIpcMainChannel", channel);
         }
 
         /// <summary>
@@ -171,11 +160,11 @@ namespace ElectronNET.API
 
             if(jobjects.Count > 0 || jarrays.Count > 0)
             {
-                BridgeConnector.Socket.Emit("sendToIpcRenderer", JObject.FromObject(browserWindow, _jsonSerializer), channel, jarrays.ToArray(), jobjects.ToArray(), objects.ToArray());
+                BridgeConnector.Emit("sendToIpcRenderer", JObject.FromObject(browserWindow, _jsonSerializer), channel, jarrays.ToArray(), jobjects.ToArray(), objects.ToArray());
             }
             else
             {
-                BridgeConnector.Socket.Emit("sendToIpcRenderer", JObject.FromObject(browserWindow, _jsonSerializer), channel, data);
+                BridgeConnector.Emit("sendToIpcRenderer", JObject.FromObject(browserWindow, _jsonSerializer), channel, data);
             }
         }
 
@@ -210,14 +199,35 @@ namespace ElectronNET.API
 
             if(jobjects.Count > 0 || jarrays.Count > 0)
             {
-                BridgeConnector.Socket.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, jarrays.ToArray(), jobjects.ToArray(), objects.ToArray());
+                BridgeConnector.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, jarrays.ToArray(), jobjects.ToArray(), objects.ToArray());
             }
             else
             {
-                BridgeConnector.Socket.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, data);
+                BridgeConnector.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, data);
             }
         }
 
+        /// <summary>
+        /// Log a message to the console output pipe. This is used when running with "detachedProcess" : true on the electron.manifest.json,
+        /// as in that case we can't open pipes to read the console output from the child process anymore
+        /// </summary>
+        /// <param name="text">Message to log</param>
+        public static void ConsoleLog(string text)
+        {
+            BridgeConnector.Emit("console-stdout", text);
+        }
+
+        /// <summary>
+        /// Log a message to the console error pipe. This is used when running with "detachedProcess" : true on the electron.manifest.json,
+        /// as in that case we can't open pipes to read the console output from the child process anymore
+        /// </summary>
+        /// <param name="text">Message to log</param>
+
+        public static void ConsoleError(string text)
+        {
+            BridgeConnector.Emit("console-stderr", text);
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.API/Menu.cs

@@ -58,12 +58,12 @@ namespace ElectronNET.API
             menuItems.AddMenuItemsId();
             menuItems.AddSubmenuTypes();
 
-            BridgeConnector.Socket.Emit("menu-setApplicationMenu", JArray.FromObject(menuItems, _jsonSerializer));
+            BridgeConnector.Emit("menu-setApplicationMenu", JArray.FromObject(menuItems, _jsonSerializer));
             _menuItems.AddRange(menuItems);
 
-            BridgeConnector.Socket.Off("menuItemClicked");
-            BridgeConnector.Socket.On("menuItemClicked", (id) => {
-                MenuItem menuItem = _menuItems.GetMenuItem(id.ToString());
+            BridgeConnector.Off("menuItemClicked");
+            BridgeConnector.On<string>("menuItemClicked", (id) => {
+                MenuItem menuItem = _menuItems.GetMenuItem(id);
                 menuItem.Click?.Invoke();
             });
         }
@@ -87,7 +87,7 @@ namespace ElectronNET.API
             menuItems.AddMenuItemsId();
             menuItems.AddSubmenuTypes();
 
-            BridgeConnector.Socket.Emit("menu-setContextMenu", browserWindow.Id, JArray.FromObject(menuItems, _jsonSerializer));
+            BridgeConnector.Emit("menu-setContextMenu", browserWindow.Id, JArray.FromObject(menuItems, _jsonSerializer));
 
             if (!_contextMenuItems.ContainsKey(browserWindow.Id))
             {
@@ -96,13 +96,10 @@ namespace ElectronNET.API
                 ContextMenuItems = new ReadOnlyDictionary<int, ReadOnlyCollection<MenuItem>>(x);
             }
 
-            BridgeConnector.Socket.Off("contextMenuItemClicked");
-            BridgeConnector.Socket.On("contextMenuItemClicked", (results) =>
+            BridgeConnector.Off("contextMenuItemClicked");
+            BridgeConnector.On<MenuResponse>("contextMenuItemClicked", (results) =>
             {
-                var id = ((JArray)results).First.ToString();
-                var browserWindowId = (int)((JArray)results).Last;
-
-                MenuItem menuItem = _contextMenuItems[browserWindowId].GetMenuItem(id);
+                MenuItem menuItem = _contextMenuItems[results.windowId].GetMenuItem(results.id);
                 menuItem.Click?.Invoke();
             });
         }
@@ -113,7 +110,7 @@ namespace ElectronNET.API
         /// <param name="browserWindow">The browser window.</param>
         public void ContextMenuPopup(BrowserWindow browserWindow)
         {
-            BridgeConnector.Socket.Emit("menu-contextMenuPopup", browserWindow.Id);
+            BridgeConnector.Emit("menu-contextMenuPopup", browserWindow.Id);
         }
 
         private JsonSerializer _jsonSerializer = new JsonSerializer()

ElectronNET.API/MenuResponse.cs

@@ -0,0 +1,8 @@
+namespace ElectronNET.API
+{
+    internal class MenuResponse
+    {
+        public string id { get; set; }
+        public int windowId { get; set; }
+    }
+}

ElectronNET.API/NativeTheme.cs

@@ -94,88 +94,33 @@ namespace ElectronNET.API
         {
             var themeSource = themeSourceMode.GetDescription();
 
-            BridgeConnector.Socket.Emit("nativeTheme-themeSource", themeSource);
+            BridgeConnector.Emit("nativeTheme-themeSource", themeSource);
         }
 
         /// <summary>
         /// A <see cref="ThemeSourceMode"/> property that can be <see cref="ThemeSourceMode.System"/>, <see cref="ThemeSourceMode.Light"/> or <see cref="ThemeSourceMode.Dark"/>. It is used to override (<seealso cref="SetThemeSource"/>) and
         /// supercede the value that Chromium has chosen to use internally.
         /// </summary>
-        public Task<ThemeSourceMode> GetThemeSourceAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<ThemeSourceMode>();
-
-            BridgeConnector.Socket.On("nativeTheme-themeSource-getCompleted", (themeSource) =>
-            {
-                BridgeConnector.Socket.Off("nativeTheme-themeSource-getCompleted");
-
-                var themeSourceValue = (ThemeSourceMode)Enum.Parse(typeof(ThemeSourceMode), (string)themeSource, true);
-
-                taskCompletionSource.SetResult(themeSourceValue);
-            });
-
-            BridgeConnector.Socket.Emit("nativeTheme-themeSource-get");
-
-            return taskCompletionSource.Task;
-        }
+        public async Task<ThemeSourceMode> GetThemeSourceAsync() => Enum.Parse<ThemeSourceMode>(await BridgeConnector.OnResult<string>("nativeTheme-themeSource-get", "nativeTheme-themeSource-getCompleted"), true);
 
         /// <summary>
         /// A <see cref="bool"/> for if the OS / Chromium currently has a dark mode enabled or is
         /// being instructed to show a dark-style UI. If you want to modify this value you
         /// should use <see cref="SetThemeSource"/>.
         /// </summary>
-        public Task<bool> ShouldUseDarkColorsAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("nativeTheme-shouldUseDarkColors-completed", (shouldUseDarkColors) => {
-                BridgeConnector.Socket.Off("nativeTheme-shouldUseDarkColors-completed");
-
-                taskCompletionSource.SetResult((bool)shouldUseDarkColors);
-            });
-
-            BridgeConnector.Socket.Emit("nativeTheme-shouldUseDarkColors");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<bool> ShouldUseDarkColorsAsync() => BridgeConnector.OnResult<bool>("nativeTheme-shouldUseDarkColors", "nativeTheme-shouldUseDarkColors-completed");
 
         /// <summary>
         /// A <see cref="bool"/> for if the OS / Chromium currently has high-contrast mode enabled or is
         /// being instructed to show a high-contrast UI.
         /// </summary>
-        public Task<bool> ShouldUseHighContrastColorsAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("nativeTheme-shouldUseHighContrastColors-completed", (shouldUseHighContrastColors) => {
-                BridgeConnector.Socket.Off("nativeTheme-shouldUseHighContrastColors-completed");
-
-                taskCompletionSource.SetResult((bool)shouldUseHighContrastColors);
-            });
-
-            BridgeConnector.Socket.Emit("nativeTheme-shouldUseHighContrastColors");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<bool> ShouldUseHighContrastColorsAsync() => BridgeConnector.OnResult<bool>("nativeTheme-shouldUseHighContrastColors", "nativeTheme-shouldUseHighContrastColors-completed");
 
         /// <summary>
         /// A <see cref="bool"/> for if the OS / Chromium currently has an inverted color scheme or is
         /// being instructed to use an inverted color scheme.
         /// </summary>
-        public Task<bool> ShouldUseInvertedColorSchemeAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("nativeTheme-shouldUseInvertedColorScheme-completed", (shouldUseInvertedColorScheme) => {
-                BridgeConnector.Socket.Off("nativeTheme-shouldUseInvertedColorScheme-completed");
-
-                taskCompletionSource.SetResult((bool)shouldUseInvertedColorScheme);
-            });
-
-            BridgeConnector.Socket.Emit("nativeTheme-shouldUseInvertedColorScheme");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<bool> ShouldUseInvertedColorSchemeAsync() => BridgeConnector.OnResult<bool>("nativeTheme-shouldUseInvertedColorScheme", "nativeTheme-shouldUseInvertedColorScheme-completed");
 
         /// <summary>
         /// Emitted when something in the underlying NativeTheme has changed. This normally means that either the value of <see cref="ShouldUseDarkColorsAsync"/>,
@@ -187,12 +132,12 @@ namespace ElectronNET.API
             {
                 if (_updated == null)
                 {
-                    BridgeConnector.Socket.On("nativeTheme-updated" + GetHashCode(), () =>
+                    BridgeConnector.On("nativeTheme-updated" + GetHashCode(), () =>
                     {
                         _updated();
                     });
 
-                    BridgeConnector.Socket.Emit("register-nativeTheme-updated-event", GetHashCode());
+                    BridgeConnector.Emit("register-nativeTheme-updated-event", GetHashCode());
                 }
                 _updated += value;
             }
@@ -202,7 +147,7 @@ namespace ElectronNET.API
 
                 if (_updated == null)
                 {
-                    BridgeConnector.Socket.Off("nativeTheme-updated" + GetHashCode());
+                    BridgeConnector.Off("nativeTheme-updated" + GetHashCode());
                 }
             }
         }

ElectronNET.API/Notification.cs

@@ -48,7 +48,7 @@ namespace ElectronNET.API
         {
             GenerateIDsForDefinedActions(notificationOptions);
 
-            BridgeConnector.Socket.Emit("createNotification", JObject.FromObject(notificationOptions, _jsonSerializer));
+            BridgeConnector.Emit("createNotification", notificationOptions);
         }
 
         private static void GenerateIDsForDefinedActions(NotificationOptions notificationOptions)
@@ -60,9 +60,9 @@ namespace ElectronNET.API
                 notificationOptions.ShowID = Guid.NewGuid().ToString();
                 isActionDefined = true;
 
-                BridgeConnector.Socket.Off("NotificationEventShow");
-                BridgeConnector.Socket.On("NotificationEventShow", (id) => {
-                    _notificationOptions.Single(x => x.ShowID == id.ToString()).OnShow();
+                BridgeConnector.Off("NotificationEventShow");
+                BridgeConnector.On<string>("NotificationEventShow", (id) => {
+                    _notificationOptions.Single(x => x.ShowID == id).OnShow();
                 });
             }
 
@@ -71,9 +71,9 @@ namespace ElectronNET.API
                 notificationOptions.ClickID = Guid.NewGuid().ToString();
                 isActionDefined = true;
 
-                BridgeConnector.Socket.Off("NotificationEventClick");
-                BridgeConnector.Socket.On("NotificationEventClick", (id) => {
-                    _notificationOptions.Single(x => x.ClickID == id.ToString()).OnClick();
+                BridgeConnector.Off("NotificationEventClick");
+                BridgeConnector.On<string>("NotificationEventClick", (id) => {
+                    _notificationOptions.Single(x => x.ClickID == id).OnClick();
                 });
             }
 
@@ -82,8 +82,8 @@ namespace ElectronNET.API
                 notificationOptions.CloseID = Guid.NewGuid().ToString();
                 isActionDefined = true;
 
-                BridgeConnector.Socket.Off("NotificationEventClose");
-                BridgeConnector.Socket.On("NotificationEventClose", (id) => {
+                BridgeConnector.Off("NotificationEventClose");
+                BridgeConnector.On<string>("NotificationEventClose", (id) => {
                     _notificationOptions.Single(x => x.CloseID == id.ToString()).OnClose();
                 });
             }
@@ -93,10 +93,9 @@ namespace ElectronNET.API
                 notificationOptions.ReplyID = Guid.NewGuid().ToString();
                 isActionDefined = true;
 
-                BridgeConnector.Socket.Off("NotificationEventReply");
-                BridgeConnector.Socket.On("NotificationEventReply", (args) => {
-                    var arguments = ((JArray)args).ToObject<string[]>();
-                    _notificationOptions.Single(x => x.ReplyID == arguments[0].ToString()).OnReply(arguments[1].ToString());
+                BridgeConnector.Off("NotificationEventReply");
+                BridgeConnector.On<string[]>("NotificationEventReply", (args) => {
+                    _notificationOptions.Single(x => x.ReplyID == args[0].ToString()).OnReply(args[1].ToString());
                 });
             }
 
@@ -105,10 +104,9 @@ namespace ElectronNET.API
                 notificationOptions.ActionID = Guid.NewGuid().ToString();
                 isActionDefined = true;
 
-                BridgeConnector.Socket.Off("NotificationEventAction");
-                BridgeConnector.Socket.On("NotificationEventAction", (args) => {
-                    var arguments = ((JArray)args).ToObject<string[]>();
-                    _notificationOptions.Single(x => x.ReplyID == arguments[0].ToString()).OnAction(arguments[1].ToString());
+                BridgeConnector.Off("NotificationEventAction");
+                BridgeConnector.On<string[]>("NotificationEventAction", (args) => {
+                    _notificationOptions.Single(x => x.ReplyID == args[0].ToString()).OnAction(args[1].ToString());
                 });
             }
 
@@ -124,24 +122,17 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<bool> IsSupportedAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
+            var taskCompletionSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            BridgeConnector.Socket.On("notificationIsSupportedComplete", (isSupported) =>
+            BridgeConnector.On<bool>("notificationIsSupportedComplete", (isSupported) =>
             {
-                BridgeConnector.Socket.Off("notificationIsSupportedComplete");
-                taskCompletionSource.SetResult((bool)isSupported);
+                BridgeConnector.Off("notificationIsSupportedComplete");
+                taskCompletionSource.SetResult(isSupported);
             });
 
-            BridgeConnector.Socket.Emit("notificationIsSupported");
+            BridgeConnector.Emit("notificationIsSupported");
 
             return taskCompletionSource.Task;
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
     }
 }

ElectronNET.API/PowerMonitor.cs

@@ -17,12 +17,12 @@ namespace ElectronNET.API
             {
                 if (_lockScreen == null)
                 {
-                    BridgeConnector.Socket.On("pm-lock-screen" , () =>
+                    BridgeConnector.On("pm-lock-screen" , () =>
                     {
                         _lockScreen();
                     });
 
-                    BridgeConnector.Socket.Emit("register-pm-lock-screen");
+                    BridgeConnector.Emit("register-pm-lock-screen");
                 }
                 _lockScreen += value;
             }
@@ -31,7 +31,7 @@ namespace ElectronNET.API
                 _lockScreen -= value;
 
                 if (_lockScreen == null)
-                    BridgeConnector.Socket.Off("pm-lock-screen");
+                    BridgeConnector.Off("pm-lock-screen");
             }
         }
 
@@ -46,12 +46,12 @@ namespace ElectronNET.API
             {
                 if (_unlockScreen == null)
                 {
-                    BridgeConnector.Socket.On("pm-unlock-screen", () =>
+                    BridgeConnector.On("pm-unlock-screen", () =>
                     {
                         _unlockScreen();
                     });
 
-                    BridgeConnector.Socket.Emit("register-pm-unlock-screen");
+                    BridgeConnector.Emit("register-pm-unlock-screen");
                 }
                 _unlockScreen += value;
             }
@@ -60,7 +60,7 @@ namespace ElectronNET.API
                 _unlockScreen -= value;
 
                 if (_unlockScreen == null)
-                    BridgeConnector.Socket.Off("pm-unlock-screen");
+                    BridgeConnector.Off("pm-unlock-screen");
             }
         }
 
@@ -75,12 +75,12 @@ namespace ElectronNET.API
             {
                 if (_suspend == null)
                 {
-                    BridgeConnector.Socket.On("pm-suspend", () =>
+                    BridgeConnector.On("pm-suspend", () =>
                     {
                         _suspend();
                     });
 
-                    BridgeConnector.Socket.Emit("register-pm-suspend");
+                    BridgeConnector.Emit("register-pm-suspend");
                 }
                 _suspend += value;
             }
@@ -89,7 +89,7 @@ namespace ElectronNET.API
                 _suspend -= value;
 
                 if (_suspend == null)
-                    BridgeConnector.Socket.Off("pm-suspend");
+                    BridgeConnector.Off("pm-suspend");
             }
         }
 
@@ -104,12 +104,12 @@ namespace ElectronNET.API
             {
                 if (_resume == null)
                 {
-                    BridgeConnector.Socket.On("pm-resume", () =>
+                    BridgeConnector.On("pm-resume", () =>
                     {
                         _resume();
                     });
 
-                    BridgeConnector.Socket.Emit("register-pm-resume");
+                    BridgeConnector.Emit("register-pm-resume");
                 }
                 _resume += value;
             }
@@ -118,7 +118,7 @@ namespace ElectronNET.API
                 _resume -= value;
 
                 if (_resume == null)
-                    BridgeConnector.Socket.Off("pm-resume");
+                    BridgeConnector.Off("pm-resume");
             }
         }
 
@@ -133,12 +133,12 @@ namespace ElectronNET.API
             {
                 if (_onAC == null)
                 {
-                    BridgeConnector.Socket.On("pm-on-ac", () =>
+                    BridgeConnector.On("pm-on-ac", () =>
                     {
                         _onAC();
                     });
 
-                    BridgeConnector.Socket.Emit("register-pm-on-ac");
+                    BridgeConnector.Emit("register-pm-on-ac");
                 }
                 _onAC += value;
             }
@@ -147,7 +147,7 @@ namespace ElectronNET.API
                 _onAC -= value;
 
                 if (_onAC == null)
-                    BridgeConnector.Socket.Off("pm-on-ac");
+                    BridgeConnector.Off("pm-on-ac");
             }
         }
 
@@ -162,12 +162,12 @@ namespace ElectronNET.API
             {
                 if (_onBattery == null)
                 {
-                    BridgeConnector.Socket.On("pm-on-battery", () =>
+                    BridgeConnector.On("pm-on-battery", () =>
                     {
                         _onBattery();
                     });
 
-                    BridgeConnector.Socket.Emit("register-pm-on-battery");
+                    BridgeConnector.Emit("register-pm-on-battery");
                 }
                 _onBattery += value;
             }
@@ -176,7 +176,7 @@ namespace ElectronNET.API
                 _onBattery -= value;
 
                 if (_onBattery == null)
-                    BridgeConnector.Socket.Off("pm-on-battery");
+                    BridgeConnector.Off("pm-on-battery");
             }
         }
 
@@ -195,12 +195,12 @@ namespace ElectronNET.API
             {
                 if (_shutdown == null)
                 {
-                    BridgeConnector.Socket.On("pm-shutdown", () =>
+                    BridgeConnector.On("pm-shutdown", () =>
                     {
                         _shutdown();
                     });
 
-                    BridgeConnector.Socket.Emit("register-pm-shutdown");
+                    BridgeConnector.Emit("register-pm-shutdown");
                 }
                 _shutdown += value;
             }
@@ -209,7 +209,7 @@ namespace ElectronNET.API
                 _shutdown -= value;
 
                 if (_shutdown == null)
-                    BridgeConnector.Socket.Off("pm-on-shutdown");
+                    BridgeConnector.Off("pm-on-shutdown");
             }
         }
 

ElectronNET.API/Screen.cs

@@ -21,12 +21,12 @@ namespace ElectronNET.API
             {
                 if (_onDisplayAdded == null)
                 {
-                    BridgeConnector.Socket.On("screen-display-added-event" + GetHashCode(), (display) =>
+                    BridgeConnector.On<Display>("screen-display-added-event" + GetHashCode(), (display) =>
                     {
-                        _onDisplayAdded(((JObject)display).ToObject<Display>());
+                        _onDisplayAdded(display);
                     });
 
-                    BridgeConnector.Socket.Emit("register-screen-display-added", GetHashCode());
+                    BridgeConnector.Emit("register-screen-display-added", GetHashCode());
                 }
                 _onDisplayAdded += value;
             }
@@ -35,7 +35,7 @@ namespace ElectronNET.API
                 _onDisplayAdded -= value;
 
                 if (_onDisplayAdded == null)
-                    BridgeConnector.Socket.Off("screen-display-added-event" + GetHashCode());
+                    BridgeConnector.Off("screen-display-added-event" + GetHashCode());
             }
         }
 
@@ -50,12 +50,12 @@ namespace ElectronNET.API
             {
                 if (_onDisplayRemoved == null)
                 {
-                    BridgeConnector.Socket.On("screen-display-removed-event" + GetHashCode(), (display) =>
+                    BridgeConnector.On<Display>("screen-display-removed-event" + GetHashCode(), (display) =>
                     {
-                        _onDisplayRemoved(((JObject)display).ToObject<Display>());
+                        _onDisplayRemoved(display);
                     });
 
-                    BridgeConnector.Socket.Emit("register-screen-display-removed", GetHashCode());
+                    BridgeConnector.Emit("register-screen-display-removed", GetHashCode());
                 }
                 _onDisplayRemoved += value;
             }
@@ -64,7 +64,7 @@ namespace ElectronNET.API
                 _onDisplayRemoved -= value;
 
                 if (_onDisplayRemoved == null)
-                    BridgeConnector.Socket.Off("screen-display-removed-event" + GetHashCode());
+                    BridgeConnector.Off("screen-display-removed-event" + GetHashCode());
             }
         }
 
@@ -81,15 +81,12 @@ namespace ElectronNET.API
             {
                 if (_onDisplayMetricsChanged == null)
                 {
-                    BridgeConnector.Socket.On("screen-display-metrics-changed-event" + GetHashCode(), (args) =>
+                    BridgeConnector.On<DisplayChanged>("screen-display-metrics-changed-event" + GetHashCode(), (args) =>
                     {
-                        var display = ((JArray)args).First.ToObject<Display>();
-                        var metrics = ((JArray)args).Last.ToObject<string[]>();
-
-                        _onDisplayMetricsChanged(display, metrics);
+                        _onDisplayMetricsChanged(args.display, args.metrics);
                     });
 
-                    BridgeConnector.Socket.Emit("register-screen-display-metrics-changed", GetHashCode());
+                    BridgeConnector.Emit("register-screen-display-metrics-changed", GetHashCode());
                 }
                 _onDisplayMetricsChanged += value;
             }
@@ -98,7 +95,7 @@ namespace ElectronNET.API
                 _onDisplayMetricsChanged -= value;
 
                 if (_onDisplayMetricsChanged == null)
-                    BridgeConnector.Socket.Off("screen-display-metrics-changed-event" + GetHashCode());
+                    BridgeConnector.Off("screen-display-metrics-changed-event" + GetHashCode());
             }
         }
 
@@ -132,128 +129,38 @@ namespace ElectronNET.API
         /// The current absolute position of the mouse pointer.
         /// </summary>
         /// <returns></returns>
-        public Task<Point> GetCursorScreenPointAsync() 
-        {
-            var taskCompletionSource = new TaskCompletionSource<Point>();
-
-            BridgeConnector.Socket.On("screen-getCursorScreenPointCompleted", (point) =>
-            {
-                BridgeConnector.Socket.Off("screen-getCursorScreenPointCompleted");
-
-                taskCompletionSource.SetResult(((JObject)point).ToObject<Point>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getCursorScreenPoint");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<Point> GetCursorScreenPointAsync() => BridgeConnector.OnResult<Point>("screen-getCursorScreenPoint", "screen-getCursorScreenPointCompleted");
 
         /// <summary>
         /// macOS: The height of the menu bar in pixels.
         /// </summary>
         /// <returns>The height of the menu bar in pixels.</returns>
-        public Task<int> GetMenuBarHeightAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<int>();
-
-            BridgeConnector.Socket.On("screen-getMenuBarHeightCompleted", (height) =>
-            {
-                BridgeConnector.Socket.Off("screen-getMenuBarHeightCompleted");
-
-                taskCompletionSource.SetResult(int.Parse(height.ToString()));
-            });
-
-            BridgeConnector.Socket.Emit("screen-getMenuBarHeight");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<int> GetMenuBarHeightAsync() => BridgeConnector.OnResult<int>("screen-getMenuBarHeight", "screen-getMenuBarHeightCompleted");
 
         /// <summary>
         /// The primary display.
         /// </summary>
         /// <returns></returns>
-        public Task<Display> GetPrimaryDisplayAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<Display>();
+        public Task<Display> GetPrimaryDisplayAsync() => BridgeConnector.OnResult<Display>("screen-getPrimaryDisplay", "screen-getPrimaryDisplayCompleted");
 
-            BridgeConnector.Socket.On("screen-getPrimaryDisplayCompleted", (display) =>
-            {
-                BridgeConnector.Socket.Off("screen-getPrimaryDisplayCompleted");
-
-                taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getPrimaryDisplay");
-
-            return taskCompletionSource.Task;
-        }
 
         /// <summary>
         /// An array of displays that are currently available.
         /// </summary>
         /// <returns>An array of displays that are currently available.</returns>
-        public Task<Display[]> GetAllDisplaysAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<Display[]>();
-
-            BridgeConnector.Socket.On("screen-getAllDisplaysCompleted", (displays) =>
-            {
-                BridgeConnector.Socket.Off("screen-getAllDisplaysCompleted");
-
-                taskCompletionSource.SetResult(((JArray)displays).ToObject<Display[]>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getAllDisplays");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<Display[]> GetAllDisplaysAsync() => BridgeConnector.OnResult<Display[]>("screen-getAllDisplays", "screen-getAllDisplaysCompleted");
 
         /// <summary>
         /// The display nearest the specified point.
         /// </summary>
         /// <returns>The display nearest the specified point.</returns>
-        public Task<Display> GetDisplayNearestPointAsync(Point point)
-        {
-            var taskCompletionSource = new TaskCompletionSource<Display>();
-
-            BridgeConnector.Socket.On("screen-getDisplayNearestPointCompleted", (display) =>
-            {
-                BridgeConnector.Socket.Off("screen-getDisplayNearestPointCompleted");
-
-                taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getDisplayNearestPoint", JObject.FromObject(point, _jsonSerializer));
-
-            return taskCompletionSource.Task;
-        }
+        public Task<Display> GetDisplayNearestPointAsync(Point point) => BridgeConnector.OnResult<Display>("screen-getDisplayNearestPoint", "screen-getDisplayNearestPointCompleted", point);
 
         /// <summary>
         /// The display that most closely intersects the provided bounds.
         /// </summary>
         /// <param name="rectangle"></param>
         /// <returns>The display that most closely intersects the provided bounds.</returns>
-        public Task<Display> GetDisplayMatchingAsync(Rectangle rectangle)
-        {
-            var taskCompletionSource = new TaskCompletionSource<Display>();
-
-            BridgeConnector.Socket.On("screen-getDisplayMatching", (display) =>
-            {
-                BridgeConnector.Socket.Off("screen-getDisplayMatching");
-
-                taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
-            });
-
-            BridgeConnector.Socket.Emit("screen-getDisplayMatching", JObject.FromObject(rectangle, _jsonSerializer));
-
-            return taskCompletionSource.Task;
-        }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
+        public Task<Display> GetDisplayMatchingAsync(Rectangle rectangle) => BridgeConnector.OnResult<Display>("screen-getDisplayMatching", "screen-getDisplayMatchingCompleted", rectangle);
     }
 }

ElectronNET.API/Session.cs

@@ -37,7 +37,7 @@ namespace ElectronNET.API
         /// <param name="domains">A comma-separated list of servers for which integrated authentication is enabled.</param>
         public void AllowNTLMCredentialsForDomains(string domains)
         {
-            BridgeConnector.Socket.Emit("webContents-session-allowNTLMCredentialsForDomains", Id, domains);
+            BridgeConnector.Emit("webContents-session-allowNTLMCredentialsForDomains", Id, domains);
         }
 
         /// <summary>
@@ -47,16 +47,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task ClearAuthCacheAsync(RemovePassword options)
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-clearAuthCache-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-clearAuthCache-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-clearAuthCache-completed" + guid);
+                BridgeConnector.Off("webContents-session-clearAuthCache-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-clearAuthCache", Id, JObject.FromObject(options, _jsonSerializer), guid);
+            BridgeConnector.Emit("webContents-session-clearAuthCache", Id, options, guid);
 
             return taskCompletionSource.Task;
         }
@@ -66,16 +66,16 @@ namespace ElectronNET.API
         /// </summary>
         public Task ClearAuthCacheAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-clearAuthCache-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-clearAuthCache-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-clearAuthCache-completed" + guid);
+                BridgeConnector.Off("webContents-session-clearAuthCache-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-clearAuthCache", Id, guid);
+            BridgeConnector.Emit("webContents-session-clearAuthCache", Id, guid);
 
             return taskCompletionSource.Task;
         }
@@ -86,16 +86,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task ClearCacheAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-clearCache-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-clearCache-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-clearCache-completed" + guid);
+                BridgeConnector.Off("webContents-session-clearCache-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-clearCache", Id, guid);
+            BridgeConnector.Emit("webContents-session-clearCache", Id, guid);
 
             return taskCompletionSource.Task;
         }
@@ -106,16 +106,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task ClearHostResolverCacheAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-clearHostResolverCache-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-clearHostResolverCache-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-clearHostResolverCache-completed" + guid);
+                BridgeConnector.Off("webContents-session-clearHostResolverCache-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-clearHostResolverCache", Id, guid);
+            BridgeConnector.Emit("webContents-session-clearHostResolverCache", Id, guid);
 
             return taskCompletionSource.Task;
         }
@@ -126,16 +126,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task ClearStorageDataAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-clearStorageData-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-clearStorageData-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-clearStorageData-completed" + guid);
+                BridgeConnector.Off("webContents-session-clearStorageData-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-clearStorageData", Id, guid);
+            BridgeConnector.Emit("webContents-session-clearStorageData", Id, guid);
 
             return taskCompletionSource.Task;
         }
@@ -147,16 +147,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task ClearStorageDataAsync(ClearStorageDataOptions options)
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-clearStorageData-options-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-clearStorageData-options-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-clearStorageData-options-completed" + guid);
+                BridgeConnector.Off("webContents-session-clearStorageData-options-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-clearStorageData-options", Id, JObject.FromObject(options, _jsonSerializer), guid);
+            BridgeConnector.Emit("webContents-session-clearStorageData-options", Id, options, guid);
 
             return taskCompletionSource.Task;
         }
@@ -171,7 +171,7 @@ namespace ElectronNET.API
         /// <param name="options"></param>
         public void CreateInterruptedDownload(CreateInterruptedDownloadOptions options)
         {
-            BridgeConnector.Socket.Emit("webContents-session-createInterruptedDownload", Id, JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("webContents-session-createInterruptedDownload", Id, options);
         }
 
         /// <summary>
@@ -180,7 +180,7 @@ namespace ElectronNET.API
         /// </summary>
         public void DisableNetworkEmulation()
         {
-            BridgeConnector.Socket.Emit("webContents-session-disableNetworkEmulation", Id);
+            BridgeConnector.Emit("webContents-session-disableNetworkEmulation", Id);
         }
 
         /// <summary>
@@ -189,7 +189,7 @@ namespace ElectronNET.API
         /// <param name="options"></param>
         public void EnableNetworkEmulation(EnableNetworkEmulationOptions options)
         {
-            BridgeConnector.Socket.Emit("webContents-session-enableNetworkEmulation", Id, JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("webContents-session-enableNetworkEmulation", Id, options);
         }
 
         /// <summary>
@@ -197,7 +197,7 @@ namespace ElectronNET.API
         /// </summary>
         public void FlushStorageData()
         {
-            BridgeConnector.Socket.Emit("webContents-session-flushStorageData", Id);
+            BridgeConnector.Emit("webContents-session-flushStorageData", Id);
         }
 
         /// <summary>
@@ -207,18 +207,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<int[]> GetBlobDataAsync(string identifier)
         {
-            var taskCompletionSource = new TaskCompletionSource<int[]>();
+            var taskCompletionSource = new TaskCompletionSource<int[]>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-getBlobData-completed" + guid, (buffer) =>
+            BridgeConnector.On<int[]>("webContents-session-getBlobData-completed" + guid, (buffer) =>
             {
-                var result = ((JArray)buffer).ToObject<int[]>();
-
-                BridgeConnector.Socket.Off("webContents-session-getBlobData-completed" + guid);
-                taskCompletionSource.SetResult(result);
+                BridgeConnector.Off("webContents-session-getBlobData-completed" + guid);
+                taskCompletionSource.SetResult(buffer);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-getBlobData", Id, identifier, guid);
+            BridgeConnector.Emit("webContents-session-getBlobData", Id, identifier, guid);
 
             return taskCompletionSource.Task;
         }
@@ -229,16 +227,16 @@ namespace ElectronNET.API
         /// <returns>Callback is invoked with the session's current cache size.</returns>
         public Task<int> GetCacheSizeAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<int>();
+            var taskCompletionSource = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-getCacheSize-completed" + guid, (size) =>
+            BridgeConnector.On<int>("webContents-session-getCacheSize-completed" + guid, (size) =>
             {
-                BridgeConnector.Socket.Off("webContents-session-getCacheSize-completed" + guid);
-                taskCompletionSource.SetResult((int)size);
+                BridgeConnector.Off("webContents-session-getCacheSize-completed" + guid);
+                taskCompletionSource.SetResult(size);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-getCacheSize", Id, guid);
+            BridgeConnector.Emit("webContents-session-getCacheSize", Id, guid);
 
             return taskCompletionSource.Task;
         }
@@ -249,17 +247,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<string[]> GetPreloadsAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<string[]>();
+            var taskCompletionSource = new TaskCompletionSource<string[]>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-getPreloads-completed" + guid, (preloads) =>
+            BridgeConnector.On<string[]>("webContents-session-getPreloads-completed" + guid, (preloads) =>
             {
-                var result = ((JArray)preloads).ToObject<string[]>();
-                BridgeConnector.Socket.Off("webContents-session-getPreloads-completed" + guid);
-                taskCompletionSource.SetResult(result);
+                BridgeConnector.Off("webContents-session-getPreloads-completed" + guid);
+                taskCompletionSource.SetResult(preloads);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-getPreloads", Id, guid);
+            BridgeConnector.Emit("webContents-session-getPreloads", Id, guid);
 
             return taskCompletionSource.Task;
         }
@@ -270,16 +267,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<string> GetUserAgent()
         {
-            var taskCompletionSource = new TaskCompletionSource<string>();
+            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-getUserAgent-completed" + guid, (userAgent) =>
+            BridgeConnector.On<string>("webContents-session-getUserAgent-completed" + guid, (userAgent) =>
             {
-                BridgeConnector.Socket.Off("webContents-session-getUserAgent-completed" + guid);
+                BridgeConnector.Off("webContents-session-getUserAgent-completed" + guid);
                 taskCompletionSource.SetResult(userAgent.ToString());
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-getUserAgent", Id, guid);
+            BridgeConnector.Emit("webContents-session-getUserAgent", Id, guid);
 
             return taskCompletionSource.Task;
         }
@@ -292,16 +289,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<string> ResolveProxyAsync(string url)
         {
-            var taskCompletionSource = new TaskCompletionSource<string>();
+            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-resolveProxy-completed" + guid, (proxy) =>
+            BridgeConnector.On<string>("webContents-session-resolveProxy-completed" + guid, (proxy) =>
             {
-                BridgeConnector.Socket.Off("webContents-session-resolveProxy-completed" + guid);
+                BridgeConnector.Off("webContents-session-resolveProxy-completed" + guid);
                 taskCompletionSource.SetResult(proxy.ToString());
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-resolveProxy", Id, url, guid);
+            BridgeConnector.Emit("webContents-session-resolveProxy", Id, url, guid);
 
             return taskCompletionSource.Task;
         }
@@ -313,7 +310,7 @@ namespace ElectronNET.API
         /// <param name="path"></param>
         public void SetDownloadPath(string path)
         {
-            BridgeConnector.Socket.Emit("webContents-session-setDownloadPath", Id, path);
+            BridgeConnector.Emit("webContents-session-setDownloadPath", Id, path);
         }
 
         /// <summary>
@@ -323,7 +320,7 @@ namespace ElectronNET.API
         /// <param name="preloads"></param>
         public void SetPreloads(string[] preloads)
         {
-            BridgeConnector.Socket.Emit("webContents-session-setPreloads", Id, preloads);
+            BridgeConnector.Emit("webContents-session-setPreloads", Id, preloads);
         }
 
         /// <summary>
@@ -334,16 +331,16 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task SetProxyAsync(ProxyConfig config)
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("webContents-session-setProxy-completed" + guid, () =>
+            BridgeConnector.On("webContents-session-setProxy-completed" + guid, () =>
             {
-                BridgeConnector.Socket.Off("webContents-session-setProxy-completed" + guid);
+                BridgeConnector.Off("webContents-session-setProxy-completed" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-setProxy", Id, JObject.FromObject(config, _jsonSerializer), guid);
+            BridgeConnector.Emit("webContents-session-setProxy", Id, config, guid);
 
             return taskCompletionSource.Task;
         }
@@ -356,7 +353,7 @@ namespace ElectronNET.API
         /// <param name="userAgent"></param>
         public void SetUserAgent(string userAgent)
         {
-            BridgeConnector.Socket.Emit("webContents-session-setUserAgent", Id, userAgent);
+            BridgeConnector.Emit("webContents-session-setUserAgent", Id, userAgent);
         }
 
         /// <summary>
@@ -372,7 +369,7 @@ namespace ElectronNET.API
         /// example "en-US,fr,de,ko,zh-CN,ja".</param>
         public void SetUserAgent(string userAgent, string acceptLanguages)
         {
-            BridgeConnector.Socket.Emit("webContents-session-setUserAgent", Id, userAgent, acceptLanguages);
+            BridgeConnector.Emit("webContents-session-setUserAgent", Id, userAgent, acceptLanguages);
         }
 
         /// <summary>
@@ -382,17 +379,15 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<ChromeExtensionInfo[]> GetAllExtensionsAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<ChromeExtensionInfo[]>();
+            var taskCompletionSource = new TaskCompletionSource<ChromeExtensionInfo[]>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            BridgeConnector.Socket.On("webContents-session-getAllExtensions-completed", (extensionslist) =>
+            BridgeConnector.On<ChromeExtensionInfo[]>("webContents-session-getAllExtensions-completed", (extensionslist) =>
             {
-                BridgeConnector.Socket.Off("webContents-session-getAllExtensions-completed");
-                var chromeExtensionInfos = ((JArray)extensionslist).ToObject<ChromeExtensionInfo[]>();
-
-                taskCompletionSource.SetResult(chromeExtensionInfos);
+                BridgeConnector.Off("webContents-session-getAllExtensions-completed");
+                taskCompletionSource.SetResult(extensionslist);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-getAllExtensions", Id);
+            BridgeConnector.Emit("webContents-session-getAllExtensions", Id);
 
             return taskCompletionSource.Task;
         }
@@ -404,7 +399,7 @@ namespace ElectronNET.API
         /// <param name="name">Name of the Chrome extension to remove</param>
         public void RemoveExtension(string name)
         {
-            BridgeConnector.Socket.Emit("webContents-session-removeExtension", Id, name);
+            BridgeConnector.Emit("webContents-session-removeExtension", Id, name);
         }
 
         /// <summary>
@@ -436,25 +431,18 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<Extension> LoadExtensionAsync(string path, bool allowFileAccess = false)
         {
-            var taskCompletionSource = new TaskCompletionSource<Extension>();
+            var taskCompletionSource = new TaskCompletionSource<Extension>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            BridgeConnector.Socket.On("webContents-session-loadExtension-completed", (extension) =>
+            BridgeConnector.On<Extension>("webContents-session-loadExtension-completed", (extension) =>
             {
-                BridgeConnector.Socket.Off("webContents-session-loadExtension-completed");
+                BridgeConnector.Off("webContents-session-loadExtension-completed");
 
-                taskCompletionSource.SetResult(((JObject)extension).ToObject<Extension>());
+                taskCompletionSource.SetResult(extension);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-loadExtension", Id, path, allowFileAccess);
+            BridgeConnector.Emit("webContents-session-loadExtension", Id, path, allowFileAccess);
 
             return taskCompletionSource.Task;
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
     }
 }

ElectronNET.API/Shell.cs

@@ -42,14 +42,14 @@ namespace ElectronNET.API
         /// <param name="fullPath">The full path to the directory / file.</param>
         public Task ShowItemInFolderAsync(string fullPath)
         {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+            var taskCompletionSource = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            BridgeConnector.Socket.On("shell-showItemInFolderCompleted", () =>
+            BridgeConnector.On("shell-showItemInFolderCompleted", () =>
             {
-                BridgeConnector.Socket.Off("shell-showItemInFolderCompleted");
+                BridgeConnector.Off("shell-showItemInFolderCompleted");
             });
 
-            BridgeConnector.Socket.Emit("shell-showItemInFolder", fullPath);
+            BridgeConnector.Emit("shell-showItemInFolder", fullPath);
 
             return taskCompletionSource.Task;
         }
@@ -61,16 +61,16 @@ namespace ElectronNET.API
         /// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
         public Task<string> OpenPathAsync(string path)
         {
-            var taskCompletionSource = new TaskCompletionSource<string>();
+            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            BridgeConnector.Socket.On("shell-openPathCompleted", (errorMessage) =>
+            BridgeConnector.On<string>("shell-openPathCompleted", (errorMessage) =>
             {
-                BridgeConnector.Socket.Off("shell-openPathCompleted");
+                BridgeConnector.Off("shell-openPathCompleted");
 
-                taskCompletionSource.SetResult((string) errorMessage);
+                taskCompletionSource.SetResult(errorMessage);
             });
 
-            BridgeConnector.Socket.Emit("shell-openPath", path);
+            BridgeConnector.Emit("shell-openPath", path);
 
             return taskCompletionSource.Task;
         }
@@ -95,22 +95,22 @@ namespace ElectronNET.API
         /// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
         public Task<string> OpenExternalAsync(string url, OpenExternalOptions options)
         {
-            var taskCompletionSource = new TaskCompletionSource<string>();
+            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            BridgeConnector.Socket.On("shell-openExternalCompleted", (error) =>
+            BridgeConnector.On<string>("shell-openExternalCompleted", (error) =>
             {
-                BridgeConnector.Socket.Off("shell-openExternalCompleted");
+                BridgeConnector.Off("shell-openExternalCompleted");
 
-                taskCompletionSource.SetResult((string) error);
+                taskCompletionSource.SetResult(error);
             });
 
             if (options == null)
             {
-                BridgeConnector.Socket.Emit("shell-openExternal", url);
+                BridgeConnector.Emit("shell-openExternal", url);
             }
             else
             {
-                BridgeConnector.Socket.Emit("shell-openExternal", url, JObject.FromObject(options, _jsonSerializer));
+                BridgeConnector.Emit("shell-openExternal", url, options);
             }
 
             return taskCompletionSource.Task;
@@ -123,18 +123,7 @@ namespace ElectronNET.API
         /// <returns> Whether the item was successfully moved to the trash.</returns>
         public Task<bool> TrashItemAsync(string fullPath)
         {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-trashItem-completed", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-trashItem-completed");
-
-                taskCompletionSource.SetResult((bool) success);
-            });
-
-            BridgeConnector.Socket.Emit("shell-trashItem", fullPath);
-
-            return taskCompletionSource.Task;
+            return BridgeConnector.OnResult<bool>("shell-trashItem", "shell-trashItem-completed", fullPath);
         }
 
         /// <summary>
@@ -142,7 +131,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Beep()
         {
-            BridgeConnector.Socket.Emit("shell-beep");
+            BridgeConnector.Emit("shell-beep");
         }
 
         /// <summary>
@@ -154,18 +143,7 @@ namespace ElectronNET.API
         /// <returns>Whether the shortcut was created successfully.</returns>
         public Task<bool> WriteShortcutLinkAsync(string shortcutPath, ShortcutLinkOperation operation, ShortcutDetails options)
         {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("shell-writeShortcutLinkCompleted", (success) =>
-            {
-                BridgeConnector.Socket.Off("shell-writeShortcutLinkCompleted");
-
-                taskCompletionSource.SetResult((bool) success);
-            });
-
-            BridgeConnector.Socket.Emit("shell-writeShortcutLink", shortcutPath, operation.GetDescription(), JObject.FromObject(options, _jsonSerializer));
-
-            return taskCompletionSource.Task;
+            return BridgeConnector.OnResult<bool>("shell-writeShortcutLink", "shell-writeShortcutLinkCompleted", shortcutPath, operation.GetDescription(), options);
         }
 
         /// <summary>
@@ -176,28 +154,7 @@ namespace ElectronNET.API
         /// <returns><see cref="ShortcutDetails"/> of the shortcut.</returns>
         public Task<ShortcutDetails> ReadShortcutLinkAsync(string shortcutPath)
         {
-            var taskCompletionSource = new TaskCompletionSource<ShortcutDetails>();
-
-            BridgeConnector.Socket.On("shell-readShortcutLinkCompleted", (shortcutDetails) =>
-            {
-                BridgeConnector.Socket.Off("shell-readShortcutLinkCompleted");
-
-                var shortcutObject = shortcutDetails as JObject;
-                var details = shortcutObject?.ToObject<ShortcutDetails>();
-
-                taskCompletionSource.SetResult(details);
-            });
-
-            BridgeConnector.Socket.Emit("shell-readShortcutLink", shortcutPath);
-
-            return taskCompletionSource.Task;
+            return BridgeConnector.OnResult<ShortcutDetails>("shell-readShortcutLink", "shell-readShortcutLinkCompleted", shortcutPath);
         }
-
-        private readonly JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
     }
 }

ElectronNET.API/Tray.cs

@@ -23,15 +23,12 @@ namespace ElectronNET.API
             {
                 if (_click == null)
                 {
-                    BridgeConnector.Socket.On("tray-click-event" + GetHashCode(), (result) =>
+                    BridgeConnector.On<TrayClickEventResponse>("tray-click-event" + GetHashCode(), (result) =>
                     {
-                        var args = ((JArray)result).ToObject<object[]>();
-                        var trayClickEventArgs = ((JObject)args[0]).ToObject<TrayClickEventArgs>();
-                        var bounds = ((JObject)args[1]).ToObject<Rectangle>();
-                        _click(trayClickEventArgs, bounds);
+                        _click(result.eventArgs, result.bounds);
                     });
 
-                    BridgeConnector.Socket.Emit("register-tray-click", GetHashCode());
+                    BridgeConnector.Emit("register-tray-click", GetHashCode());
                 }
                 _click += value;
             }
@@ -40,7 +37,7 @@ namespace ElectronNET.API
                 _click -= value;
 
                 if (_click == null)
-                    BridgeConnector.Socket.Off("tray-click-event" + GetHashCode());
+                    BridgeConnector.Off("tray-click-event" + GetHashCode());
             }
         }
 
@@ -55,15 +52,12 @@ namespace ElectronNET.API
             {
                 if (_rightClick == null)
                 {
-                    BridgeConnector.Socket.On("tray-right-click-event" + GetHashCode(), (result) =>
+                    BridgeConnector.On<TrayClickEventResponse>("tray-right-click-event" + GetHashCode(), (result) =>
                     {
-                        var args = ((JArray)result).ToObject<object[]>();
-                        var trayClickEventArgs = ((JObject)args[0]).ToObject<TrayClickEventArgs>();
-                        var bounds = ((JObject)args[1]).ToObject<Rectangle>();
-                        _rightClick(trayClickEventArgs, bounds);
+                        _rightClick(result.eventArgs, result.bounds);
                     });
 
-                    BridgeConnector.Socket.Emit("register-tray-right-click", GetHashCode());
+                    BridgeConnector.Emit("register-tray-right-click", GetHashCode());
                 }
                 _rightClick += value;
             }
@@ -72,7 +66,7 @@ namespace ElectronNET.API
                 _rightClick -= value;
 
                 if (_rightClick == null)
-                    BridgeConnector.Socket.Off("tray-right-click-event" + GetHashCode());
+                    BridgeConnector.Off("tray-right-click-event" + GetHashCode());
             }
         }
 
@@ -87,15 +81,12 @@ namespace ElectronNET.API
             {
                 if (_doubleClick == null)
                 {
-                    BridgeConnector.Socket.On("tray-double-click-event" + GetHashCode(), (result) =>
+                    BridgeConnector.On<TrayClickEventResponse>("tray-double-click-event" + GetHashCode(), (result) =>
                     {
-                        var args = ((JArray)result).ToObject<object[]>();
-                        var trayClickEventArgs = ((JObject)args[0]).ToObject<TrayClickEventArgs>();
-                        var bounds = ((JObject)args[1]).ToObject<Rectangle>();
-                        _doubleClick(trayClickEventArgs, bounds);
+                        _doubleClick(result.eventArgs, result.bounds);
                     });
 
-                    BridgeConnector.Socket.Emit("register-tray-double-click", GetHashCode());
+                    BridgeConnector.Emit("register-tray-double-click", GetHashCode());
                 }
                 _doubleClick += value;
             }
@@ -104,7 +95,7 @@ namespace ElectronNET.API
                 _doubleClick -= value;
 
                 if (_doubleClick == null)
-                    BridgeConnector.Socket.Off("tray-double-click-event" + GetHashCode());
+                    BridgeConnector.Off("tray-double-click-event" + GetHashCode());
             }
         }
 
@@ -119,12 +110,12 @@ namespace ElectronNET.API
             {
                 if (_balloonShow == null)
                 {
-                    BridgeConnector.Socket.On("tray-balloon-show-event" + GetHashCode(), () =>
+                    BridgeConnector.On("tray-balloon-show-event" + GetHashCode(), () =>
                     {
                         _balloonShow();
                     });
 
-                    BridgeConnector.Socket.Emit("register-tray-balloon-show", GetHashCode());
+                    BridgeConnector.Emit("register-tray-balloon-show", GetHashCode());
                 }
                 _balloonShow += value;
             }
@@ -133,7 +124,7 @@ namespace ElectronNET.API
                 _balloonShow -= value;
 
                 if (_balloonShow == null)
-                    BridgeConnector.Socket.Off("tray-balloon-show-event" + GetHashCode());
+                    BridgeConnector.Off("tray-balloon-show-event" + GetHashCode());
             }
         }
 
@@ -148,12 +139,12 @@ namespace ElectronNET.API
             {
                 if (_balloonClick == null)
                 {
-                    BridgeConnector.Socket.On("tray-balloon-click-event" + GetHashCode(), () =>
+                    BridgeConnector.On("tray-balloon-click-event" + GetHashCode(), () =>
                     {
                         _balloonClick();
                     });
 
-                    BridgeConnector.Socket.Emit("register-tray-balloon-click", GetHashCode());
+                    BridgeConnector.Emit("register-tray-balloon-click", GetHashCode());
                 }
                 _balloonClick += value;
             }
@@ -162,7 +153,7 @@ namespace ElectronNET.API
                 _balloonClick -= value;
 
                 if (_balloonClick == null)
-                    BridgeConnector.Socket.Off("tray-balloon-click-event" + GetHashCode());
+                    BridgeConnector.Off("tray-balloon-click-event" + GetHashCode());
             }
         }
 
@@ -178,12 +169,12 @@ namespace ElectronNET.API
             {
                 if (_balloonClosed == null)
                 {
-                    BridgeConnector.Socket.On("tray-balloon-closed-event" + GetHashCode(), () =>
+                    BridgeConnector.On("tray-balloon-closed-event" + GetHashCode(), () =>
                     {
                         _balloonClosed();
                     });
 
-                    BridgeConnector.Socket.Emit("register-tray-balloon-closed", GetHashCode());
+                    BridgeConnector.Emit("register-tray-balloon-closed", GetHashCode());
                 }
                 _balloonClosed += value;
             }
@@ -192,7 +183,7 @@ namespace ElectronNET.API
                 _balloonClosed -= value;
 
                 if (_balloonClosed == null)
-                    BridgeConnector.Socket.Off("tray-balloon-closed-event" + GetHashCode());
+                    BridgeConnector.Off("tray-balloon-closed-event" + GetHashCode());
             }
         }
 
@@ -251,12 +242,12 @@ namespace ElectronNET.API
         public void Show(string image, MenuItem[] menuItems)
         {
             menuItems.AddMenuItemsId();
-            BridgeConnector.Socket.Emit("create-tray", image, JArray.FromObject(menuItems, _jsonSerializer));
+            BridgeConnector.Emit("create-tray", image, JArray.FromObject(menuItems, _jsonSerializer));
             _items.Clear();
             _items.AddRange(menuItems);
 
-            BridgeConnector.Socket.Off("trayMenuItemClicked");
-            BridgeConnector.Socket.On("trayMenuItemClicked", (id) =>
+            BridgeConnector.Off("trayMenuItemClicked");
+            BridgeConnector.On<string>("trayMenuItemClicked", (id) =>
             {
                 MenuItem menuItem = _items.GetMenuItem(id.ToString());
                 menuItem?.Click();
@@ -269,7 +260,7 @@ namespace ElectronNET.API
         /// <param name="image">The image.</param>
         public void Show(string image)
         {
-            BridgeConnector.Socket.Emit("create-tray", image);
+            BridgeConnector.Emit("create-tray", image);
         }
 
         /// <summary>
@@ -277,7 +268,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Destroy()
         {
-            BridgeConnector.Socket.Emit("tray-destroy");
+            BridgeConnector.Emit("tray-destroy");
             _items.Clear();
         }
 
@@ -287,7 +278,7 @@ namespace ElectronNET.API
         /// <param name="image"></param>
         public void SetImage(string image)
         {
-            BridgeConnector.Socket.Emit("tray-setImage", image);
+            BridgeConnector.Emit("tray-setImage", image);
         }
 
         /// <summary>
@@ -296,7 +287,7 @@ namespace ElectronNET.API
         /// <param name="image"></param>
         public void SetPressedImage(string image)
         {
-            BridgeConnector.Socket.Emit("tray-setPressedImage", image);
+            BridgeConnector.Emit("tray-setPressedImage", image);
         }
 
         /// <summary>
@@ -305,7 +296,7 @@ namespace ElectronNET.API
         /// <param name="toolTip"></param>
         public void SetToolTip(string toolTip)
         {
-            BridgeConnector.Socket.Emit("tray-setToolTip", toolTip);
+            BridgeConnector.Emit("tray-setToolTip", toolTip);
         }
 
         /// <summary>
@@ -314,7 +305,7 @@ namespace ElectronNET.API
         /// <param name="title"></param>
         public void SetTitle(string title)
         {
-            BridgeConnector.Socket.Emit("tray-setTitle", title);
+            BridgeConnector.Emit("tray-setTitle", title);
         }
 
         /// <summary>
@@ -323,63 +314,49 @@ namespace ElectronNET.API
         /// <param name="options"></param>
         public void DisplayBalloon(DisplayBalloonOptions options)
         {
-            BridgeConnector.Socket.Emit("tray-displayBalloon", JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("tray-displayBalloon", options);
         }
 
         /// <summary>
         /// Whether the tray icon is destroyed.
         /// </summary>
         /// <returns></returns>
-        public Task<bool> IsDestroyedAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
+        public Task<bool> IsDestroyedAsync() => BridgeConnector.OnResult<bool>("tray-isDestroyed", "tray-isDestroyedCompleted");
 
-            BridgeConnector.Socket.On("tray-isDestroyedCompleted", (isDestroyed) =>
-            {
-                BridgeConnector.Socket.Off("tray-isDestroyedCompleted");
+        private const string ModuleName = "tray";
 
-                taskCompletionSource.SetResult((bool)isDestroyed);
-            });
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        public void On(string eventName, Action fn) => Events.Instance.On(ModuleName, eventName, fn);
 
-            BridgeConnector.Socket.Emit("tray-isDestroyed");
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        public void On(string eventName, Action<object> fn) => Events.Instance.On(ModuleName, eventName, fn);
 
-            return taskCompletionSource.Task;
-        }
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module once.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        public void Once(string eventName, Action fn) => Events.Instance.Once(ModuleName, eventName, fn);
+
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module once.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        public void Once(string eventName, Action<object> fn) => Events.Instance.Once(ModuleName, eventName, fn);
 
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
             NullValueHandling = NullValueHandling.Ignore
         };
-
-        private const string ModuleName = "tray";
-        /// <summary>
-        /// Subscribe to an unmapped event on the <see cref="Tray"/> module.
-        /// </summary>
-        /// <param name="eventName">The event name</param>
-        /// <param name="fn">The handler</param>
-        public void On(string eventName, Action fn)
-            => Events.Instance.On(ModuleName, eventName, fn);
-        /// <summary>
-        /// Subscribe to an unmapped event on the <see cref="Tray"/> module.
-        /// </summary>
-        /// <param name="eventName">The event name</param>
-        /// <param name="fn">The handler</param>
-        public void On(string eventName, Action<object> fn)
-            => Events.Instance.On(ModuleName, eventName, fn);
-        /// <summary>
-        /// Subscribe to an unmapped event on the <see cref="Tray"/> module once.
-        /// </summary>
-        /// <param name="eventName">The event name</param>
-        /// <param name="fn">The handler</param>
-        public void Once(string eventName, Action fn)
-            => Events.Instance.Once(ModuleName, eventName, fn);
-        /// <summary>
-        /// Subscribe to an unmapped event on the <see cref="Tray"/> module once.
-        /// </summary>
-        /// <param name="eventName">The event name</param>
-        /// <param name="fn">The handler</param>
-        public void Once(string eventName, Action<object> fn)
-            => Events.Instance.Once(ModuleName, eventName, fn);
     }
 }

ElectronNET.API/WebContents.cs

@@ -34,12 +34,12 @@ namespace ElectronNET.API
             {
                 if (_crashed == null)
                 {
-                    BridgeConnector.Socket.On("webContents-crashed" + Id, (killed) =>
+                    BridgeConnector.On<bool>("webContents-crashed" + Id, (killed) =>
                     {
-                        _crashed((bool)killed);
+                        _crashed(killed);
                     });
 
-                    BridgeConnector.Socket.Emit("register-webContents-crashed", Id);
+                    BridgeConnector.Emit("register-webContents-crashed", Id);
                 }
                 _crashed += value;
             }
@@ -48,7 +48,7 @@ namespace ElectronNET.API
                 _crashed -= value;
 
                 if (_crashed == null)
-                    BridgeConnector.Socket.Off("webContents-crashed" + Id);
+                    BridgeConnector.Off("webContents-crashed" + Id);
             }
         }
 
@@ -64,12 +64,12 @@ namespace ElectronNET.API
             {
                 if (_didFinishLoad == null)
                 {
-                    BridgeConnector.Socket.On("webContents-didFinishLoad" + Id, () =>
+                    BridgeConnector.On("webContents-didFinishLoad" + Id, () =>
                     {
                         _didFinishLoad();
                     });
 
-                    BridgeConnector.Socket.Emit("register-webContents-didFinishLoad", Id);
+                    BridgeConnector.Emit("register-webContents-didFinishLoad", Id);
                 }
                 _didFinishLoad += value;
             }
@@ -78,7 +78,7 @@ namespace ElectronNET.API
                 _didFinishLoad -= value;
 
                 if (_didFinishLoad == null)
-                    BridgeConnector.Socket.Off("webContents-didFinishLoad" + Id);
+                    BridgeConnector.Off("webContents-didFinishLoad" + Id);
             }
         }
 
@@ -95,7 +95,7 @@ namespace ElectronNET.API
         /// </summary>
         public void OpenDevTools()
         {
-            BridgeConnector.Socket.Emit("webContentsOpenDevTools", Id);
+            BridgeConnector.Emit("webContentsOpenDevTools", Id);
         }
 
         /// <summary>
@@ -104,7 +104,7 @@ namespace ElectronNET.API
         /// <param name="openDevToolsOptions"></param>
         public void OpenDevTools(OpenDevToolsOptions openDevToolsOptions)
         {
-            BridgeConnector.Socket.Emit("webContentsOpenDevTools", Id, JObject.FromObject(openDevToolsOptions, _jsonSerializer));
+            BridgeConnector.Emit("webContentsOpenDevTools", Id, openDevToolsOptions);
         }
 
         /// <summary>
@@ -113,18 +113,7 @@ namespace ElectronNET.API
         /// <returns>printers</returns>
         public Task<PrinterInfo[]> GetPrintersAsync()
         {
-            var taskCompletionSource = new TaskCompletionSource<PrinterInfo[]>();
-
-            BridgeConnector.Socket.On("webContents-getPrinters-completed", (printers) =>
-            {
-                BridgeConnector.Socket.Off("webContents-getPrinters-completed");
-
-                taskCompletionSource.SetResult(((Newtonsoft.Json.Linq.JArray)printers).ToObject<PrinterInfo[]>());
-            });
-
-            BridgeConnector.Socket.Emit("webContents-getPrinters", Id);
-
-            return taskCompletionSource.Task;
+            return BridgeConnector.OnResult<PrinterInfo[]>("webContents-getPrinters", "webContents-getPrinters-completed" + Id, Id);
         }
 
         /// <summary>
@@ -132,27 +121,8 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="options"></param>
         /// <returns>success</returns>
-        public Task<bool> PrintAsync(PrintOptions options = null)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("webContents-print-completed", (success) =>
-            {
-                BridgeConnector.Socket.Off("webContents-print-completed");
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            if(options == null)
-            {
-                BridgeConnector.Socket.Emit("webContents-print", Id, "");
-            }
-            else
-            {
-                BridgeConnector.Socket.Emit("webContents-print", Id, JObject.FromObject(options, _jsonSerializer));
-            }
-
-            return taskCompletionSource.Task;
-        }
+        public Task<bool> PrintAsync(PrintOptions options = null) => options is null ? BridgeConnector.OnResult<bool>("webContents-print", "webContents-print-completed" + Id, Id, "")
+                                                                                     : BridgeConnector.OnResult<bool>("webContents-print", "webContents-print-completed" + Id, Id, options);
 
         /// <summary>
         /// Prints window's web page as PDF with Chromium's preview printing custom
@@ -163,27 +133,8 @@ namespace ElectronNET.API
         /// <param name="path"></param>
         /// <param name="options"></param>
         /// <returns>success</returns>
-        public Task<bool> PrintToPDFAsync(string path, PrintToPDFOptions options = null)
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("webContents-printToPDF-completed", (success) =>
-            {
-                BridgeConnector.Socket.Off("webContents-printToPDF-completed");
-                taskCompletionSource.SetResult((bool)success);
-            });
-
-            if(options == null)
-            {
-                BridgeConnector.Socket.Emit("webContents-printToPDF", Id, "", path);
-            }
-            else
-            {
-                BridgeConnector.Socket.Emit("webContents-printToPDF", Id, JObject.FromObject(options, _jsonSerializer), path);
-            }
-
-            return taskCompletionSource.Task;
-        }
+        public Task<bool> PrintToPDFAsync(string path, PrintToPDFOptions options = null) => options is null ? BridgeConnector.OnResult<bool>("webContents-printToPDF", "webContents-printToPDF-completed" + Id, Id, "", path)
+                                                                                                            : BridgeConnector.OnResult<bool>("webContents-printToPDF", "webContents-printToPDF-completed" + Id, Id, options, path);
 
         /// <summary>
         /// Is used to get the Url of the loaded page.
@@ -192,18 +143,7 @@ namespace ElectronNET.API
         /// <returns>URL of the loaded page</returns>
         public Task<string> GetUrl()
         {
-            var taskCompletionSource = new TaskCompletionSource<string>();
-
-            var eventString = "webContents-getUrl" + Id;
-            BridgeConnector.Socket.On(eventString, (url) =>
-            {
-                BridgeConnector.Socket.Off(eventString);
-                taskCompletionSource.SetResult((string)url);
-            });
-
-            BridgeConnector.Socket.Emit("webContents-getUrl", Id);
-
-            return taskCompletionSource.Task;
+            return BridgeConnector.OnResult<string>("webContents-getUrl", "webContents-getUrl" + Id, Id);
         }
 
         /// <summary>
@@ -237,23 +177,24 @@ namespace ElectronNET.API
         /// <param name="url"></param>
         /// <param name="options"></param>
         public Task LoadURLAsync(string url, LoadURLOptions options)
-        {
-            var taskCompletionSource = new TaskCompletionSource<object>();
+        {  
+            var taskCompletionSource = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            BridgeConnector.Socket.On("webContents-loadURL-complete" + Id, () =>
+            BridgeConnector.On("webContents-loadURL-complete" + Id, () =>
             {
-                BridgeConnector.Socket.Off("webContents-loadURL-complete" + Id);
-                BridgeConnector.Socket.Off("webContents-loadURL-error" + Id);
-                taskCompletionSource.SetResult(null);
+                BridgeConnector.Off("webContents-loadURL-complete" + Id);
+                BridgeConnector.Off("webContents-loadURL-error" + Id);
+                taskCompletionSource.SetResult();
             });
 
-            BridgeConnector.Socket.On("webContents-loadURL-error" + Id, (error) =>
+            BridgeConnector.On<string>("webContents-loadURL-error" + Id, (error) =>
             {
-                BridgeConnector.Socket.Off("webContents-loadURL-error" + Id);
+                BridgeConnector.Off("webContents-loadURL-error" + Id);
+                BridgeConnector.Off("webContents-loadURL-complete" + Id);
                 taskCompletionSource.SetException(new InvalidOperationException(error.ToString()));
             });
 
-            BridgeConnector.Socket.Emit("webContents-loadURL", Id, url, JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("webContents-loadURL", Id, url, options);
 
             return taskCompletionSource.Task;
         }
@@ -267,14 +208,7 @@ namespace ElectronNET.API
         /// <param name="path">Absolute path to the CSS file location</param>
         public void InsertCSS(bool isBrowserWindow, string path)
         {
-            BridgeConnector.Socket.Emit("webContents-insertCSS", Id, isBrowserWindow, path);
+            BridgeConnector.Emit("webContents-insertCSS", Id, isBrowserWindow, path);
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
     }
 }

ElectronNET.API/WindowManager.cs

@@ -50,7 +50,7 @@ namespace ElectronNET.API
             get { return _isQuitOnWindowAllClosed; }
             set
             {
-                BridgeConnector.Socket.Emit("quit-app-window-all-closed-event", value);
+                BridgeConnector.Emit("quit-app-window-all-closed-event", value);
                 _isQuitOnWindowAllClosed = value;
             }
         }
@@ -92,24 +92,21 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<BrowserWindow> CreateWindowAsync(BrowserWindowOptions options, string loadUrl = "http://localhost")
         {
-            var taskCompletionSource = new TaskCompletionSource<BrowserWindow>();
+            var taskCompletionSource = new TaskCompletionSource<BrowserWindow>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            BridgeConnector.Socket.On("BrowserWindowCreated", (id) =>
+            BridgeConnector.On<int>("BrowserWindowCreated", (id) =>
             {
-                BridgeConnector.Socket.Off("BrowserWindowCreated");
+                BridgeConnector.Off("BrowserWindowCreated");
 
-                string windowId = id.ToString();
-                BrowserWindow browserWindow = new BrowserWindow(int.Parse(windowId));
+                BrowserWindow browserWindow = new BrowserWindow(id);
                 _browserWindows.Add(browserWindow);
 
                 taskCompletionSource.SetResult(browserWindow);
             });
 
-            BridgeConnector.Socket.Off("BrowserWindowClosed");
-            BridgeConnector.Socket.On("BrowserWindowClosed", (ids) =>
+            BridgeConnector.Off("BrowserWindowClosed");
+            BridgeConnector.On<int[]>("BrowserWindowClosed", (browserWindowIds) =>
             {
-                var browserWindowIds = ((JArray)ids).ToObject<int[]>();
-
                 for (int index = 0; index < _browserWindows.Count; index++)
                 {
                     if (!browserWindowIds.Contains(_browserWindows[index].Id))
@@ -137,7 +134,7 @@ namespace ElectronNET.API
                 options.X = 0;
                 options.Y = 0;
 
-                BridgeConnector.Socket.Emit("createBrowserWindow", JObject.FromObject(options, _jsonSerializer), loadUrl);
+                BridgeConnector.Emit("createBrowserWindow", options, loadUrl);
             }
             else
             {
@@ -153,7 +150,8 @@ namespace ElectronNET.API
                     ContractResolver = new CamelCasePropertyNamesContractResolver(),
                     NullValueHandling = NullValueHandling.Ignore
                 };
-                BridgeConnector.Socket.Emit("createBrowserWindow", JObject.FromObject(options, ownjsonSerializer), loadUrl);
+
+                BridgeConnector.Emit("createBrowserWindow", JObject.FromObject(options, ownjsonSerializer), loadUrl);
             }
 
             return taskCompletionSource.Task;
@@ -184,35 +182,28 @@ namespace ElectronNET.API
         /// <returns></returns>
         public Task<BrowserView> CreateBrowserViewAsync(BrowserViewConstructorOptions options)
         {
-            var taskCompletionSource = new TaskCompletionSource<BrowserView>();
+            var taskCompletionSource = new TaskCompletionSource<BrowserView>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            BridgeConnector.Socket.On("BrowserViewCreated", (id) =>
+            BridgeConnector.On<int>("BrowserViewCreated", (id) =>
             {
-                BridgeConnector.Socket.Off("BrowserViewCreated");
+                BridgeConnector.Off("BrowserViewCreated");
 
-                string browserViewId = id.ToString();
-                BrowserView browserView = new BrowserView(int.Parse(browserViewId));
+                BrowserView browserView = new BrowserView(id);
 
                 _browserViews.Add(browserView);
 
                 taskCompletionSource.SetResult(browserView);
             });
 
-            var ownjsonSerializer = new JsonSerializer()
+            var keepDefaultValuesSerializer = new JsonSerializer()
             {
                 ContractResolver = new CamelCasePropertyNamesContractResolver(),
-                NullValueHandling = NullValueHandling.Ignore
+                NullValueHandling = NullValueHandling.Ignore,
+                DefaultValueHandling = DefaultValueHandling.Include
             };
-            BridgeConnector.Socket.Emit("createBrowserView", JObject.FromObject(options, ownjsonSerializer));
+            BridgeConnector.Emit("createBrowserView", JObject.FromObject(options, keepDefaultValuesSerializer));
 
             return taskCompletionSource.Task;
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
-        };
     }
 }

ElectronNET.CLI/Commands/Actions/DeployEmbeddedElectronFiles.cs

@@ -6,6 +6,8 @@ namespace ElectronNET.CLI.Commands.Actions
     {
         public static void Do(string tempPath)
         {
+            EmbeddedFileHelper.PrintAllResources();
+
             EmbeddedFileHelper.DeployEmbeddedFile(tempPath, "main.js");
             EmbeddedFileHelper.DeployEmbeddedFile(tempPath, "package.json");
             EmbeddedFileHelper.DeployEmbeddedFile(tempPath, "build-helper.js");

ElectronNET.CLI/Commands/BuildCommand.cs

@@ -35,18 +35,19 @@ namespace ElectronNET.CLI.Commands
             _args = args;
         }
 
-        private string _paramTarget = "target";
-        private string _paramDotNetConfig = "dotnet-configuration";
-        private string _paramElectronArch = "electron-arch";
-        private string _paramElectronParams = "electron-params";
-        private string _paramOutputDirectory = "relative-path";
-        private string _paramAbsoluteOutput = "absolute-path";
-        private string _paramPackageJson = "package-json";
-        private string _paramForceNodeInstall = "install-modules";
-        private string _manifest = "manifest";
-        private string _paramPublishReadyToRun = "PublishReadyToRun";
-        private string _paramPublishSingleFile = "PublishSingleFile";
-        private string _paramVersion = "Version";
+        private const string _paramTarget = "target";
+        private const string _paramDotNetConfig = "dotnet-configuration";
+        private const string _paramElectronArch = "electron-arch";
+        private const string _paramElectronParams = "electron-params";
+        private const string _paramElectronVersion = "electron-version";
+        private const string _paramOutputDirectory = "relative-path";
+        private const string _paramAbsoluteOutput = "absolute-path";
+        private const string _paramPackageJson = "package-json";
+        private const string _paramForceNodeInstall = "install-modules";
+        private const string _manifest = "manifest";
+        private const string _paramPublishReadyToRun = "PublishReadyToRun";
+        private const string _paramPublishSingleFile = "PublishSingleFile";
+        private const string _paramVersion = "Version";
 
         public Task<bool> ExecuteAsync()
         {
@@ -105,7 +106,7 @@ namespace ElectronNET.CLI.Commands
 
                 Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid} under {configuration}-Configuration...");
                 
-                var dotNetPublishFlags = GetDotNetPublishFlags(parser);
+                var dotNetPublishFlags = GetDotNetPublishFlags(parser, "false", "false");
 
                 var command =
                     $"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {string.Join(' ', dotNetPublishFlags.Select(kvp => $"{kvp.Key}={kvp.Value}"))} --self-contained";
@@ -135,10 +136,11 @@ namespace ElectronNET.CLI.Commands
 
                 var checkForNodeModulesDirPath = Path.Combine(tempPath, "node_modules");
 
-                if (Directory.Exists(checkForNodeModulesDirPath) == false || parser.Contains(_paramForceNodeInstall) || parser.Contains(_paramPackageJson))
-
+                if (!Directory.Exists(checkForNodeModulesDirPath)|| parser.Contains(_paramForceNodeInstall) || parser.Contains(_paramPackageJson))
+                {
                     Console.WriteLine("Start npm install...");
-                ProcessHelper.CmdExecute("npm install --production", tempPath);
+                    ProcessHelper.CmdExecute("npm install --production", tempPath);
+                }
 
                 Console.WriteLine("ElectronHostHook handling started...");
 
@@ -177,6 +179,12 @@ namespace ElectronNET.CLI.Commands
                     electronArch = parser.Arguments[_paramElectronArch][0];
                 }
 
+                string electronVersion = "13.1.5";
+                if (parser.Arguments.ContainsKey(_paramElectronVersion))
+                {
+                    electronVersion = parser.Arguments[_paramElectronVersion][0];
+                }
+
                 string electronParams = "";
                 if (parser.Arguments.ContainsKey(_paramElectronParams))
                 {
@@ -199,7 +207,7 @@ namespace ElectronNET.CLI.Commands
                         : $"node build-helper.js {manifestFileName} {version}", tempPath);
 
                 Console.WriteLine($"Package Electron App for Platform {platformInfo.ElectronPackerPlatform}...");
-                ProcessHelper.CmdExecute($"npx electron-builder --config=./bin/electron-builder.json --{platformInfo.ElectronPackerPlatform} --{electronArch} -c.electronVersion=13.1.5 {electronParams}", tempPath);
+                ProcessHelper.CmdExecute($"npx electron-builder --config=./bin/electron-builder.json --{platformInfo.ElectronPackerPlatform} --{electronArch} -c.electronVersion={electronVersion} {electronParams}", tempPath);
 
                 Console.WriteLine("... done");
 
@@ -207,12 +215,12 @@ namespace ElectronNET.CLI.Commands
             });
         }
 
-        private Dictionary<string, string> GetDotNetPublishFlags(SimpleCommandLineParser parser)
+        internal static Dictionary<string, string> GetDotNetPublishFlags(SimpleCommandLineParser parser, string defaultReadyToRun, string defaultSingleFile)
         {
             var dotNetPublishFlags = new Dictionary<string, string>
             {
-                {"/p:PublishReadyToRun", parser.TryGet(_paramPublishReadyToRun, out var rtr) ? rtr[0] : "true"},
-                {"/p:PublishSingleFile", parser.TryGet(_paramPublishSingleFile, out var psf) ? psf[0] : "false"},
+                {"/p:PublishReadyToRun", parser.TryGet(_paramPublishReadyToRun, out var rtr) ? rtr[0] : defaultReadyToRun},
+                {"/p:PublishSingleFile", parser.TryGet(_paramPublishSingleFile, out var psf) ? psf[0] : defaultSingleFile},
             };
 
             if (parser.Arguments.ContainsKey(_paramVersion))

ElectronNET.CLI/Commands/StartElectronCommand.cs

@@ -22,14 +22,13 @@ namespace ElectronNET.CLI.Commands
             _args = args;
         }
 
-        private string _aspCoreProjectPath = "project-path";
-        private string _arguments = "args";
-        private string _manifest = "manifest";
-        private string _clearCache = "clear-cache";
-        private string _paramPublishReadyToRun = "PublishReadyToRun";
-        private string _paramPublishSingleFile = "PublishSingleFile";
-        private string _paramDotNetConfig = "dotnet-configuration";
-        private string _paramTarget = "target";
+        private const string _aspCoreProjectPath = "project-path";
+        private const string _arguments = "args";
+        private const string _manifest = "manifest";
+        private const string _clearCache = "clear-cache";
+        private const string _paramDotNetConfig = "dotnet-configuration";
+        private const string _paramTarget = "target";
+        private const string _buildInsteadOfPublish = "simple-build";
 
         public Task<bool> ExecuteAsync()
         {
@@ -55,34 +54,26 @@ namespace ElectronNET.CLI.Commands
                     aspCoreProjectPath = Directory.GetCurrentDirectory();
                 }
 
+
+                bool buildInsteadOfPublish = false;
+
+                if (parser.Arguments.ContainsKey(_buildInsteadOfPublish))
+                {
+                    buildInsteadOfPublish = bool.Parse(parser.Arguments[_buildInsteadOfPublish].First());
+                }
+
                 string tempPath = Path.Combine(aspCoreProjectPath, "obj", "Host");
                 if (Directory.Exists(tempPath) == false)
                 {
                     Directory.CreateDirectory(tempPath);
                 }
 
-                string tempBinPath = Path.Combine(tempPath, "bin");
+                string tempBinPath = Path.GetFullPath(Path.Combine(tempPath, "bin"));
+
+                var dotNetPublishFlags = BuildCommand.GetDotNetPublishFlags(parser, "false", "false");
+
                 var resultCode = 0;
 
-                string publishReadyToRun = "/p:PublishReadyToRun=";
-                if (parser.Arguments.ContainsKey(_paramPublishReadyToRun))
-                {
-                    publishReadyToRun += parser.Arguments[_paramPublishReadyToRun][0];
-                }
-                else
-                {
-                    publishReadyToRun += "true";
-                }
-
-                string publishSingleFile = "/p:PublishSingleFile=";
-                if (parser.Arguments.ContainsKey(_paramPublishSingleFile))
-                {
-                    publishSingleFile += parser.Arguments[_paramPublishSingleFile][0];
-                }
-                else
-                {
-                    publishSingleFile += "true";
-                }
 
                 // If target is specified as a command line argument, use it.
                 // Format is the same as the build command.
@@ -105,9 +96,19 @@ namespace ElectronNET.CLI.Commands
                     configuration = parser.Arguments[_paramDotNetConfig][0];
                 }
 
-                if (parser != null && !parser.Arguments.ContainsKey("watch"))
+                if (!buildInsteadOfPublish)
                 {
-                    resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {publishReadyToRun} {publishSingleFile} --no-self-contained", aspCoreProjectPath);
+                    if (parser != null && !parser.Arguments.ContainsKey("watch"))
+                    {
+                        resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {string.Join(' ', dotNetPublishFlags.Select(kvp => $"{kvp.Key}={kvp.Value}"))} --no-self-contained /p:DisabledWarnings=true", aspCoreProjectPath);
+                    }
+                }
+                else
+                {
+                    if (parser != null && !parser.Arguments.ContainsKey("watch"))
+                    {
+                        resultCode = ProcessHelper.CmdExecute($"dotnet build -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {string.Join(' ', dotNetPublishFlags.Select(kvp => $"{kvp.Key}={kvp.Value}"))} /p:DisabledWarnings=true", aspCoreProjectPath);
+                    }
                 }
 
                 if (resultCode != 0)
@@ -120,10 +121,40 @@ namespace ElectronNET.CLI.Commands
 
                 var nodeModulesDirPath = Path.Combine(tempPath, "node_modules");
 
-                Console.WriteLine("node_modules missing in: " + nodeModulesDirPath);
+                bool runNpmInstall = false;
 
-                Console.WriteLine("Start npm install...");
-                ProcessHelper.CmdExecute("npm install", tempPath);
+                Console.WriteLine("node_modules in: " + nodeModulesDirPath);
+
+                if (!Directory.Exists(nodeModulesDirPath))
+                {
+                    runNpmInstall = true;
+                }
+
+                var packagesJson = Path.Combine(tempPath, "package.json");
+                var packagesPrevious = Path.Combine(tempPath, "package.json.previous");
+
+                if (!runNpmInstall)
+                {
+
+                    if (File.Exists(packagesPrevious))
+                    {
+                        if (File.ReadAllText(packagesPrevious) != File.ReadAllText(packagesJson))
+                        {
+                            runNpmInstall = true;
+                        }
+                    }
+                    else
+                    {
+                        runNpmInstall = true;
+                    }
+                }
+
+                if (runNpmInstall)
+                {
+                    Console.WriteLine("Start npm install...");
+                    ProcessHelper.CmdExecute("npm install", tempPath);
+                    File.Copy(packagesJson, packagesPrevious, true);
+                }
 
                 Console.WriteLine("ElectronHostHook handling started...");
 
@@ -169,12 +200,14 @@ namespace ElectronNET.CLI.Commands
                 if (isWindows)
                 {
                     Console.WriteLine("Invoke electron.cmd - in dir: " + path);
+                    Console.WriteLine("\n\n---------------------------------------------------\n\n\n");
                     ProcessHelper.CmdExecute(@"electron.cmd ""..\..\main.js"" " + arguments, path);
 
                 }
                 else
                 {
                     Console.WriteLine("Invoke electron - in dir: " + path);
+                    Console.WriteLine("\n\n---------------------------------------------------\n\n\n");
                     ProcessHelper.CmdExecute(@"./electron ""../../main.js"" " + arguments, path);
                 }
 

ElectronNET.CLI/ElectronNET.CLI.csproj

@@ -13,7 +13,7 @@
     <PackageId>ElectronNET.CLI</PackageId>
     <!-- Version 99 is just set for local development stuff to avoid a conflict with "real" packages on NuGet.org -->
     <Version>99.0.0.0</Version>
-    <Authors>Gregor Biswanger, Robert Muehsig</Authors>
+    <Authors>Gregor Biswanger, Robert Muehsig, Rafael Oliveira</Authors>
     <Product>Electron.NET</Product>
     <Company />
     <Description>
@@ -81,6 +81,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(OS)' == 'Windows_NT'">
     <Exec Command="$(ProjectDir)devCleanup.cmd" IgnoreExitCode="true" />

ElectronNET.CLI/EmbeddedFileHelper.cs

@@ -7,13 +7,38 @@ namespace ElectronNET.CLI
     public static class EmbeddedFileHelper
     {
         private const string ResourcePath = "ElectronNET.CLI.{0}";
+        private const string ResourcePath2 = "ElectronNet.CLI.{0}";
 
         private static Stream GetTestResourceFileStream(string folderAndFileInProjectPath)
         {
             var asm = Assembly.GetExecutingAssembly();
             var resource = string.Format(ResourcePath, folderAndFileInProjectPath);
+            var resource2 = string.Format(ResourcePath2, folderAndFileInProjectPath);
 
-            return asm.GetManifestResourceStream(resource);
+            var stream = asm.GetManifestResourceStream(resource) ?? asm.GetManifestResourceStream(resource2);
+
+            if(stream is null)
+            {
+                PrintAllResources();
+
+                Console.WriteLine("Was missing resource: {0}", resource);
+
+                return null;
+            }
+            else
+            {
+                return stream;
+            }
+        }
+
+        public static void PrintAllResources()
+        {
+            var asm = Assembly.GetExecutingAssembly();
+
+            foreach (var n in asm.GetManifestResourceNames())
+            {
+                Console.WriteLine("Found resource : {0}", n);
+            }
         }
 
         public static void DeployEmbeddedFile(string targetPath, string file, string namespacePath = "")

ElectronNET.CLI/ProcessHelper.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 
@@ -6,6 +7,33 @@ namespace ElectronNET.CLI
 {
     public class ProcessHelper
     {
+        private static ConcurrentDictionary<Process, bool> _activeProcess = new();
+
+        public static void KillActive()
+        {
+            foreach(var kv in _activeProcess)
+            {
+                if (!kv.Key.HasExited)
+                {
+                    try
+                    {
+                        kv.Key.CloseMainWindow();
+                    }
+                    catch
+                    {
+
+                    }
+                    try
+                    {
+                        kv.Key.Kill(true);
+                    }
+                    catch
+                    {
+
+                    }
+                }
+            }
+        }
         public static int CmdExecute(string command, string workingDirectoryPath, bool output = true, bool waitForExit = true)
         {
             using (Process cmd = new Process())
@@ -43,7 +71,11 @@ namespace ElectronNET.CLI
 
                 if (waitForExit)
                 {
+                    _activeProcess[cmd] = true;
+
                     cmd.WaitForExit();
+
+                    _activeProcess.TryRemove(cmd, out _);
                 }
 
                 return cmd.ExitCode;

ElectronNET.CLI/Program.cs

@@ -4,12 +4,13 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text;
+using System.Threading.Tasks;
 
 namespace ElectronNET.CLI
 {
     class Program
     {
-        static void Main(string[] args)
+        static async Task Main(string[] args)
         {
             if (args.Length == 0)
             {
@@ -18,6 +19,12 @@ namespace ElectronNET.CLI
                 Environment.Exit(-1);
             }
 
+            Console.CancelKeyPress += (s,e) =>
+            {
+                ProcessHelper.KillActive();
+                Environment.Exit(-1);
+            };
+
             ICommand command = null;
 
             switch (args[0])
@@ -56,7 +63,7 @@ namespace ElectronNET.CLI
 
             if (command != null)
             {
-                var success = command.ExecuteAsync().Result;
+                var success = await command.ExecuteAsync();
                 if (!success)
                 {
                     Environment.Exit(-1);

ElectronNET.Host/api/app.js

@@ -151,7 +151,7 @@ module.exports = (socket, app) => {
         const success = app.requestSingleInstanceLock();
         electronSocket.emit('appRequestSingleInstanceLockCompleted', success);
         app.on('second-instance', (event, args = [], workingDirectory = '') => {
-            electronSocket.emit('secondInstance', [args, workingDirectory]);
+            electronSocket.emit('secondInstance', { args: args, workingDirectory: workingDirectory });
         });
     });
     socket.on('appHasSingleInstanceLock', () => {

ElectronNET.Host/api/app.ts

@@ -190,7 +190,7 @@ export = (socket: Socket, app: Electron.App) => {
         electronSocket.emit('appRequestSingleInstanceLockCompleted', success);
 
         app.on('second-instance', (event, args = [], workingDirectory = '') => {
-            electronSocket.emit('secondInstance', [args, workingDirectory]);
+            electronSocket.emit('secondInstance', { args: args, workingDirectory: workingDirectory });
         });
     });
 

ElectronNET.Host/api/browserView.js

@@ -24,7 +24,7 @@ const browserViewApi = (socket) => {
     });
     socket.on('browserView-getBounds', (id) => {
         const bounds = getBrowserViewById(id).getBounds();
-        electronSocket.emit('browserView-getBounds-reply', bounds);
+        electronSocket.emit('browserView-getBounds-reply' + id, bounds);
     });
     socket.on('browserView-setBounds', (id, bounds) => {
         getBrowserViewById(id).setBounds(bounds);

ElectronNET.Host/api/browserView.ts

@@ -31,7 +31,7 @@ const browserViewApi = (socket: Socket) => {
     socket.on('browserView-getBounds', (id) => {
         const bounds = getBrowserViewById(id).getBounds();
 
-        electronSocket.emit('browserView-getBounds-reply', bounds);
+        electronSocket.emit('browserView-getBounds-reply' + id, bounds);
     });
 
     socket.on('browserView-setBounds', (id, bounds) => {

ElectronNET.Host/api/browserWindows.js

@@ -25,153 +25,153 @@ module.exports = (socket, app) => {
             readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== id);
             electronSocket.emit('browserWindow-ready-to-show' + id);
         }
-        getWindowById(id).on('ready-to-show', () => {
+        getWindowById(id)?.on('ready-to-show', () => {
             readyToShowWindowsIds.push(id);
             electronSocket.emit('browserWindow-ready-to-show' + id);
         });
     });
     socket.on('register-browserWindow-page-title-updated', (id) => {
-        getWindowById(id).on('page-title-updated', (event, title) => {
+        getWindowById(id)?.on('page-title-updated', (event, title) => {
             electronSocket.emit('browserWindow-page-title-updated' + id, title);
         });
     });
     socket.on('register-browserWindow-close', (id) => {
-        getWindowById(id).on('close', () => {
+        getWindowById(id)?.on('close', () => {
             electronSocket.emit('browserWindow-close' + id);
         });
     });
     socket.on('register-browserWindow-closed', (id) => {
-        getWindowById(id).on('closed', () => {
+        getWindowById(id)?.on('closed', () => {
             electronSocket.emit('browserWindow-closed' + id);
         });
     });
     socket.on('register-browserWindow-session-end', (id) => {
-        getWindowById(id).on('session-end', () => {
+        getWindowById(id)?.on('session-end', () => {
             electronSocket.emit('browserWindow-session-end' + id);
         });
     });
     socket.on('register-browserWindow-unresponsive', (id) => {
-        getWindowById(id).on('unresponsive', () => {
+        getWindowById(id)?.on('unresponsive', () => {
             electronSocket.emit('browserWindow-unresponsive' + id);
         });
     });
     socket.on('register-browserWindow-responsive', (id) => {
-        getWindowById(id).on('responsive', () => {
+        getWindowById(id)?.on('responsive', () => {
             electronSocket.emit('browserWindow-responsive' + id);
         });
     });
     socket.on('register-browserWindow-blur', (id) => {
-        getWindowById(id).on('blur', () => {
+        getWindowById(id)?.on('blur', () => {
             electronSocket.emit('browserWindow-blur' + id);
         });
     });
     socket.on('register-browserWindow-focus', (id) => {
-        getWindowById(id).on('focus', () => {
+        getWindowById(id)?.on('focus', () => {
             electronSocket.emit('browserWindow-focus' + id);
         });
     });
     socket.on('register-browserWindow-show', (id) => {
-        getWindowById(id).on('show', () => {
+        getWindowById(id)?.on('show', () => {
             electronSocket.emit('browserWindow-show' + id);
         });
     });
     socket.on('register-browserWindow-hide', (id) => {
-        getWindowById(id).on('hide', () => {
+        getWindowById(id)?.on('hide', () => {
             electronSocket.emit('browserWindow-hide' + id);
         });
     });
     socket.on('register-browserWindow-maximize', (id) => {
-        getWindowById(id).on('maximize', () => {
+        getWindowById(id)?.on('maximize', () => {
             electronSocket.emit('browserWindow-maximize' + id);
         });
     });
     socket.on('register-browserWindow-unmaximize', (id) => {
-        getWindowById(id).on('unmaximize', () => {
+        getWindowById(id)?.on('unmaximize', () => {
             electronSocket.emit('browserWindow-unmaximize' + id);
         });
     });
     socket.on('register-browserWindow-minimize', (id) => {
-        getWindowById(id).on('minimize', () => {
+        getWindowById(id)?.on('minimize', () => {
             electronSocket.emit('browserWindow-minimize' + id);
         });
     });
     socket.on('register-browserWindow-restore', (id) => {
-        getWindowById(id).on('restore', () => {
+        getWindowById(id)?.on('restore', () => {
             electronSocket.emit('browserWindow-restore' + id);
         });
     });
     socket.on('register-browserWindow-resize', (id) => {
-        getWindowById(id).on('resize', () => {
+        getWindowById(id)?.on('resize', () => {
             electronSocket.emit('browserWindow-resize' + id);
         });
     });
     socket.on('register-browserWindow-move', (id) => {
-        getWindowById(id).on('move', () => {
+        getWindowById(id)?.on('move', () => {
             electronSocket.emit('browserWindow-move' + id);
         });
     });
     socket.on('register-browserWindow-moved', (id) => {
-        getWindowById(id).on('moved', () => {
+        getWindowById(id)?.on('moved', () => {
             electronSocket.emit('browserWindow-moved' + id);
         });
     });
     socket.on('register-browserWindow-enter-full-screen', (id) => {
-        getWindowById(id).on('enter-full-screen', () => {
+        getWindowById(id)?.on('enter-full-screen', () => {
             electronSocket.emit('browserWindow-enter-full-screen' + id);
         });
     });
     socket.on('register-browserWindow-leave-full-screen', (id) => {
-        getWindowById(id).on('leave-full-screen', () => {
+        getWindowById(id)?.on('leave-full-screen', () => {
             electronSocket.emit('browserWindow-leave-full-screen' + id);
         });
     });
     socket.on('register-browserWindow-enter-html-full-screen', (id) => {
-        getWindowById(id).on('enter-html-full-screen', () => {
+        getWindowById(id)?.on('enter-html-full-screen', () => {
             electronSocket.emit('browserWindow-enter-html-full-screen' + id);
         });
     });
     socket.on('register-browserWindow-leave-html-full-screen', (id) => {
-        getWindowById(id).on('leave-html-full-screen', () => {
+        getWindowById(id)?.on('leave-html-full-screen', () => {
             electronSocket.emit('browserWindow-leave-html-full-screen' + id);
         });
     });
     socket.on('register-browserWindow-app-command', (id) => {
-        getWindowById(id).on('app-command', (event, command) => {
+        getWindowById(id)?.on('app-command', (event, command) => {
             electronSocket.emit('browserWindow-app-command' + id, command);
         });
     });
     socket.on('register-browserWindow-scroll-touch-begin', (id) => {
-        getWindowById(id).on('scroll-touch-begin', () => {
+        getWindowById(id)?.on('scroll-touch-begin', () => {
             electronSocket.emit('browserWindow-scroll-touch-begin' + id);
         });
     });
     socket.on('register-browserWindow-scroll-touch-end', (id) => {
-        getWindowById(id).on('scroll-touch-end', () => {
+        getWindowById(id)?.on('scroll-touch-end', () => {
             electronSocket.emit('browserWindow-scroll-touch-end' + id);
         });
     });
     socket.on('register-browserWindow-scroll-touch-edge', (id) => {
-        getWindowById(id).on('scroll-touch-edge', () => {
+        getWindowById(id)?.on('scroll-touch-edge', () => {
             electronSocket.emit('browserWindow-scroll-touch-edge' + id);
         });
     });
     socket.on('register-browserWindow-swipe', (id) => {
-        getWindowById(id).on('swipe', (event, direction) => {
+        getWindowById(id)?.on('swipe', (event, direction) => {
             electronSocket.emit('browserWindow-swipe' + id, direction);
         });
     });
     socket.on('register-browserWindow-sheet-begin', (id) => {
-        getWindowById(id).on('sheet-begin', () => {
+        getWindowById(id)?.on('sheet-begin', () => {
             electronSocket.emit('browserWindow-sheet-begin' + id);
         });
     });
     socket.on('register-browserWindow-sheet-end', (id) => {
-        getWindowById(id).on('sheet-end', () => {
+        getWindowById(id)?.on('sheet-end', () => {
             electronSocket.emit('browserWindow-sheet-end' + id);
         });
     });
     socket.on('register-browserWindow-new-window-for-tab', (id) => {
-        getWindowById(id).on('new-window-for-tab', () => {
+        getWindowById(id)?.on('new-window-for-tab', () => {
             electronSocket.emit('browserWindow-new-window-for-tab' + id);
         });
     });
@@ -202,6 +202,15 @@ module.exports = (socket, app) => {
             proxyToCredentialsMap[options.proxy] = options.proxyCredentials;
         }
         window.on('ready-to-show', () => {
+            try {
+                window.id;
+            }
+            catch (error) {
+                if (error.message === 'Object has been destroyed') {
+                    return;
+                }
+            }
+
             if (readyToShowWindowsIds.includes(window.id)) {
                 readyToShowWindowsIds = readyToShowWindowsIds.filter(value => value !== window.id);
             }
@@ -250,239 +259,244 @@ module.exports = (socket, app) => {
         electronSocket.emit('BrowserWindowCreated', window.id);
     });
     socket.on('browserWindowDestroy', (id) => {
-        getWindowById(id).destroy();
+        getWindowById(id)?.destroy();
     });
     socket.on('browserWindowClose', (id) => {
-        getWindowById(id).close();
+        getWindowById(id)?.close();
     });
     socket.on('browserWindowFocus', (id) => {
-        getWindowById(id).focus();
+        getWindowById(id)?.focus();
     });
     socket.on('browserWindowBlur', (id) => {
-        getWindowById(id).blur();
+        getWindowById(id)?.blur();
     });
     socket.on('browserWindowIsFocused', (id) => {
-        const isFocused = getWindowById(id).isFocused();
-        electronSocket.emit('browserWindow-isFocused-completed', isFocused);
+        const isFocused = getWindowById(id)?.isFocused() ?? null;
+        electronSocket.emit('browserWindow-isFocused-completed' + id, isFocused);
     });
     socket.on('browserWindowIsDestroyed', (id) => {
-        const isDestroyed = getWindowById(id).isDestroyed();
-        electronSocket.emit('browserWindow-isDestroyed-completed', isDestroyed);
+        const w = getWindowById(id);
+        if (w) {
+            const isDestroyed = w.isDestroyed();
+            electronSocket.emit('browserWindow-isDestroyed-completed' + id, isDestroyed);
+        } else {
+            electronSocket.emit('browserWindow-isDestroyed-completed' + id, true);
+        }
     });
     socket.on('browserWindowShow', (id) => {
-        getWindowById(id).show();
+        getWindowById(id)?.show();
     });
     socket.on('browserWindowShowInactive', (id) => {
-        getWindowById(id).showInactive();
+        getWindowById(id)?.showInactive();
     });
     socket.on('browserWindowHide', (id) => {
-        getWindowById(id).hide();
+        getWindowById(id)?.hide();
     });
     socket.on('browserWindowIsVisible', (id) => {
-        const isVisible = getWindowById(id).isVisible();
-        electronSocket.emit('browserWindow-isVisible-completed', isVisible);
+        const isVisible = getWindowById(id)?.isVisible() ?? null;
+        electronSocket.emit('browserWindow-isVisible-completed' + id, isVisible);
     });
     socket.on('browserWindowIsModal', (id) => {
-        const isModal = getWindowById(id).isModal();
-        electronSocket.emit('browserWindow-isModal-completed', isModal);
+        const isModal = getWindowById(id)?.isModal() ?? null;
+        electronSocket.emit('browserWindow-isModal-completed' + id, isModal);
     });
     socket.on('browserWindowMaximize', (id) => {
-        getWindowById(id).maximize();
+        getWindowById(id)?.maximize();
     });
     socket.on('browserWindowUnmaximize', (id) => {
-        getWindowById(id).unmaximize();
+        getWindowById(id)?.unmaximize();
     });
     socket.on('browserWindowIsMaximized', (id) => {
-        const isMaximized = getWindowById(id).isMaximized();
-        electronSocket.emit('browserWindow-isMaximized-completed', isMaximized);
+        const isMaximized = getWindowById(id)?.isMaximized() ?? null;
+        electronSocket.emit('browserWindow-isMaximized-completed' + id, isMaximized);
     });
     socket.on('browserWindowMinimize', (id) => {
-        getWindowById(id).minimize();
+        getWindowById(id)?.minimize();
     });
     socket.on('browserWindowRestore', (id) => {
-        getWindowById(id).restore();
+        getWindowById(id)?.restore();
     });
     socket.on('browserWindowIsMinimized', (id) => {
-        const isMinimized = getWindowById(id).isMinimized();
-        electronSocket.emit('browserWindow-isMinimized-completed', isMinimized);
+        const isMinimized = getWindowById(id)?.isMinimized() ?? null;
+        electronSocket.emit('browserWindow-isMinimized-completed' + id, isMinimized);
     });
     socket.on('browserWindowSetFullScreen', (id, fullscreen) => {
-        getWindowById(id).setFullScreen(fullscreen);
+        getWindowById(id)?.setFullScreen(fullscreen);
     });
     socket.on('browserWindowIsFullScreen', (id) => {
-        const isFullScreen = getWindowById(id).isFullScreen();
-        electronSocket.emit('browserWindow-isFullScreen-completed', isFullScreen);
+        const isFullScreen = getWindowById(id)?.isFullScreen() ?? null;
+        electronSocket.emit('browserWindow-isFullScreen-completed' + id, isFullScreen);
     });
     socket.on('browserWindowSetAspectRatio', (id, aspectRatio, extraSize) => {
-        getWindowById(id).setAspectRatio(aspectRatio, extraSize);
+        getWindowById(id)?.setAspectRatio(aspectRatio, extraSize);
     });
     socket.on('browserWindowPreviewFile', (id, path, displayname) => {
-        getWindowById(id).previewFile(path, displayname);
+        getWindowById(id)?.previewFile(path, displayname);
     });
     socket.on('browserWindowCloseFilePreview', (id) => {
-        getWindowById(id).closeFilePreview();
+        getWindowById(id)?.closeFilePreview();
     });
     socket.on('browserWindowSetBounds', (id, bounds, animate) => {
-        getWindowById(id).setBounds(bounds, animate);
+        getWindowById(id)?.setBounds(bounds, animate);
     });
     socket.on('browserWindowGetBounds', (id) => {
-        const rectangle = getWindowById(id).getBounds();
-        electronSocket.emit('browserWindow-getBounds-completed', rectangle);
+        const rectangle = getWindowById(id)?.getBounds() ?? null;
+        electronSocket.emit('browserWindow-getBounds-completed' + id, rectangle);
     });
     socket.on('browserWindowSetContentBounds', (id, bounds, animate) => {
-        getWindowById(id).setContentBounds(bounds, animate);
+        getWindowById(id)?.setContentBounds(bounds, animate);
     });
     socket.on('browserWindowGetContentBounds', (id) => {
-        const rectangle = getWindowById(id).getContentBounds();
-        electronSocket.emit('browserWindow-getContentBounds-completed', rectangle);
+        const rectangle = getWindowById(id)?.getContentBounds() ?? null;
+        electronSocket.emit('browserWindow-getContentBounds-completed' + id, rectangle);
     });
     socket.on('browserWindowSetSize', (id, width, height, animate) => {
-        getWindowById(id).setSize(width, height, animate);
+        getWindowById(id)?.setSize(width, height, animate);
     });
     socket.on('browserWindowGetSize', (id) => {
-        const size = getWindowById(id).getSize();
-        electronSocket.emit('browserWindow-getSize-completed', size);
+        const size = getWindowById(id)?.getSize() ?? null;
+        electronSocket.emit('browserWindow-getSize-completed' + id, size);
     });
     socket.on('browserWindowSetContentSize', (id, width, height, animate) => {
-        getWindowById(id).setContentSize(width, height, animate);
+        getWindowById(id)?.setContentSize(width, height, animate);
     });
     socket.on('browserWindowGetContentSize', (id) => {
-        const size = getWindowById(id).getContentSize();
-        electronSocket.emit('browserWindow-getContentSize-completed', size);
+        const size = getWindowById(id)?.getContentSize() ?? null;
+        electronSocket.emit('browserWindow-getContentSize-completed' + id, size);
     });
     socket.on('browserWindowSetMinimumSize', (id, width, height) => {
-        getWindowById(id).setMinimumSize(width, height);
+        getWindowById(id)?.setMinimumSize(width, height);
     });
     socket.on('browserWindowGetMinimumSize', (id) => {
-        const size = getWindowById(id).getMinimumSize();
-        electronSocket.emit('browserWindow-getMinimumSize-completed', size);
+        const size = getWindowById(id)?.getMinimumSize() ?? null;
+        electronSocket.emit('browserWindow-getMinimumSize-completed' + id, size);
     });
     socket.on('browserWindowSetMaximumSize', (id, width, height) => {
-        getWindowById(id).setMaximumSize(width, height);
+        getWindowById(id)?.setMaximumSize(width, height);
     });
     socket.on('browserWindowGetMaximumSize', (id) => {
-        const size = getWindowById(id).getMaximumSize();
-        electronSocket.emit('browserWindow-getMaximumSize-completed', size);
+        const size = getWindowById(id)?.getMaximumSize() ?? null;
+        electronSocket.emit('browserWindow-getMaximumSize-completed' + id, size);
     });
     socket.on('browserWindowSetResizable', (id, resizable) => {
-        getWindowById(id).setResizable(resizable);
+        getWindowById(id)?.setResizable(resizable);
     });
     socket.on('browserWindowIsResizable', (id) => {
-        const resizable = getWindowById(id).isResizable();
-        electronSocket.emit('browserWindow-isResizable-completed', resizable);
+        const resizable = getWindowById(id)?.isResizable() ?? null;
+        electronSocket.emit('browserWindow-isResizable-completed' + id, resizable);
     });
     socket.on('browserWindowSetMovable', (id, movable) => {
-        getWindowById(id).setMovable(movable);
+        getWindowById(id)?.setMovable(movable);
     });
     socket.on('browserWindowIsMovable', (id) => {
-        const movable = getWindowById(id).isMovable();
-        electronSocket.emit('browserWindow-isMovable-completed', movable);
+        const movable = getWindowById(id)?.isMovable() ?? null;
+        electronSocket.emit('browserWindow-isMovable-completed' + id, movable);
     });
     socket.on('browserWindowSetMinimizable', (id, minimizable) => {
-        getWindowById(id).setMinimizable(minimizable);
+        getWindowById(id)?.setMinimizable(minimizable);
     });
     socket.on('browserWindowIsMinimizable', (id) => {
-        const minimizable = getWindowById(id).isMinimizable();
-        electronSocket.emit('browserWindow-isMinimizable-completed', minimizable);
+        const minimizable = getWindowById(id)?.isMinimizable() ?? null;
+        electronSocket.emit('browserWindow-isMinimizable-completed' + id, minimizable);
     });
     socket.on('browserWindowSetMaximizable', (id, maximizable) => {
-        getWindowById(id).setMaximizable(maximizable);
+        getWindowById(id)?.setMaximizable(maximizable);
     });
     socket.on('browserWindowIsMaximizable', (id) => {
-        const maximizable = getWindowById(id).isMaximizable();
-        electronSocket.emit('browserWindow-isMaximizable-completed', maximizable);
+        const maximizable = getWindowById(id)?.isMaximizable() ?? null;
+        electronSocket.emit('browserWindow-isMaximizable-completed' + id, maximizable);
     });
     socket.on('browserWindowSetFullScreenable', (id, fullscreenable) => {
-        getWindowById(id).setFullScreenable(fullscreenable);
+        getWindowById(id)?.setFullScreenable(fullscreenable);
     });
     socket.on('browserWindowIsFullScreenable', (id) => {
-        const fullscreenable = getWindowById(id).isFullScreenable();
-        electronSocket.emit('browserWindow-isFullScreenable-completed', fullscreenable);
+        const fullscreenable = getWindowById(id)?.isFullScreenable() ?? null;
+        electronSocket.emit('browserWindow-isFullScreenable-completed' + id, fullscreenable);
     });
     socket.on('browserWindowSetClosable', (id, closable) => {
-        getWindowById(id).setClosable(closable);
+        getWindowById(id)?.setClosable(closable);
     });
     socket.on('browserWindowIsClosable', (id) => {
-        const closable = getWindowById(id).isClosable();
-        electronSocket.emit('browserWindow-isClosable-completed', closable);
+        const closable = getWindowById(id)?.isClosable() ?? null;
+        electronSocket.emit('browserWindow-isClosable-completed' + id, closable);
     });
     socket.on('browserWindowSetAlwaysOnTop', (id, flag, level, relativeLevel) => {
-        getWindowById(id).setAlwaysOnTop(flag, level, relativeLevel);
+        getWindowById(id)?.setAlwaysOnTop(flag, level, relativeLevel);
     });
     socket.on('browserWindowIsAlwaysOnTop', (id) => {
-        const isAlwaysOnTop = getWindowById(id).isAlwaysOnTop();
-        electronSocket.emit('browserWindow-isAlwaysOnTop-completed', isAlwaysOnTop);
+        const isAlwaysOnTop = getWindowById(id)?.isAlwaysOnTop() ?? null;
+        electronSocket.emit('browserWindow-isAlwaysOnTop-completed' + id, isAlwaysOnTop);
     });
     socket.on('browserWindowCenter', (id) => {
-        getWindowById(id).center();
+        getWindowById(id)?.center();
     });
     socket.on('browserWindowSetPosition', (id, x, y, animate) => {
-        getWindowById(id).setPosition(x, y, animate);
+        getWindowById(id)?.setPosition(x, y, animate);
     });
     socket.on('browserWindowGetPosition', (id) => {
-        const position = getWindowById(id).getPosition();
-        electronSocket.emit('browserWindow-getPosition-completed', position);
+        const position = getWindowById(id)?.getPosition() ?? null;
+        electronSocket.emit('browserWindow-getPosition-completed' + id, position);
     });
     socket.on('browserWindowSetTitle', (id, title) => {
-        getWindowById(id).setTitle(title);
+        getWindowById(id)?.setTitle(title);
     });
     socket.on('browserWindowGetTitle', (id) => {
-        const title = getWindowById(id).getTitle();
-        electronSocket.emit('browserWindow-getTitle-completed', title);
+        const title = getWindowById(id)?.getTitle() ?? null;
+        electronSocket.emit('browserWindow-getTitle-completed' + id, title);
     });
     socket.on('browserWindowSetTitle', (id, title) => {
-        getWindowById(id).setTitle(title);
+        getWindowById(id)?.setTitle(title);
     });
     socket.on('browserWindowSetSheetOffset', (id, offsetY, offsetX) => {
         if (offsetX) {
-            getWindowById(id).setSheetOffset(offsetY, offsetX);
+            getWindowById(id)?.setSheetOffset(offsetY, offsetX);
         }
         else {
-            getWindowById(id).setSheetOffset(offsetY);
+            getWindowById(id)?.setSheetOffset(offsetY);
         }
     });
     socket.on('browserWindowFlashFrame', (id, flag) => {
-        getWindowById(id).flashFrame(flag);
+        getWindowById(id)?.flashFrame(flag);
     });
     socket.on('browserWindowSetSkipTaskbar', (id, skip) => {
-        getWindowById(id).setSkipTaskbar(skip);
+        getWindowById(id)?.setSkipTaskbar(skip);
     });
     socket.on('browserWindowSetKiosk', (id, flag) => {
-        getWindowById(id).setKiosk(flag);
+        getWindowById(id)?.setKiosk(flag);
     });
     socket.on('browserWindowIsKiosk', (id) => {
-        const isKiosk = getWindowById(id).isKiosk();
-        electronSocket.emit('browserWindow-isKiosk-completed', isKiosk);
+        const isKiosk = getWindowById(id)?.isKiosk() ?? null;
+        electronSocket.emit('browserWindow-isKiosk-completed' + id, isKiosk);
     });
     socket.on('browserWindowGetNativeWindowHandle', (id) => {
-        const nativeWindowHandle = getWindowById(id).getNativeWindowHandle().readInt32LE(0).toString(16);
-        electronSocket.emit('browserWindow-getNativeWindowHandle-completed', nativeWindowHandle);
+        const nativeWindowHandle = getWindowById(id)?.getNativeWindowHandle()?.readInt32LE(0)?.toString(16) ?? null;
+        electronSocket.emit('browserWindow-getNativeWindowHandle-completed' + id, nativeWindowHandle);
     });
     socket.on('browserWindowSetRepresentedFilename', (id, filename) => {
-        getWindowById(id).setRepresentedFilename(filename);
+        getWindowById(id)?.setRepresentedFilename(filename);
     });
     socket.on('browserWindowGetRepresentedFilename', (id) => {
-        const pathname = getWindowById(id).getRepresentedFilename();
-        electronSocket.emit('browserWindow-getRepresentedFilename-completed', pathname);
+        const pathname = getWindowById(id)?.getRepresentedFilename() ?? null;
+        electronSocket.emit('browserWindow-getRepresentedFilename-completed' + id, pathname);
     });
     socket.on('browserWindowSetDocumentEdited', (id, edited) => {
-        getWindowById(id).setDocumentEdited(edited);
+        getWindowById(id)?.setDocumentEdited(edited);
     });
     socket.on('browserWindowIsDocumentEdited', (id) => {
-        const edited = getWindowById(id).isDocumentEdited();
-        electronSocket.emit('browserWindow-isDocumentEdited-completed', edited);
+        const edited = getWindowById(id)?.isDocumentEdited() ?? null;
+        electronSocket.emit('browserWindow-isDocumentEdited-completed' + id, edited);
     });
     socket.on('browserWindowFocusOnWebView', (id) => {
-        getWindowById(id).focusOnWebView();
+        getWindowById(id)?.focusOnWebView();
     });
     socket.on('browserWindowBlurWebView', (id) => {
-        getWindowById(id).blurWebView();
+        getWindowById(id)?.blurWebView();
     });
     socket.on('browserWindowLoadURL', (id, url, options) => {
-        getWindowById(id).loadURL(url, options);
+        getWindowById(id)?.loadURL(url, options);
     });
     socket.on('browserWindowReload', (id) => {
-        getWindowById(id).reload();
+        getWindowById(id)?.reload();
     });
     socket.on('browserWindowSetMenu', (id, menuItems) => {
         let menu = null;
@@ -492,10 +506,10 @@ module.exports = (socket, app) => {
                 electronSocket.emit('windowMenuItemClicked', id);
             });
         }
-        getWindowById(id).setMenu(menu);
+        getWindowById(id)?.setMenu(menu);
     });
     socket.on('browserWindowRemoveMenu', (id) => {
-        getWindowById(id).removeMenu();
+        getWindowById(id)?.removeMenu();
     });
     function addMenuItemClickConnector(menuItems, callback) {
         menuItems.forEach((item) => {
@@ -508,17 +522,17 @@ module.exports = (socket, app) => {
         });
     }
     socket.on('browserWindowSetProgressBar', (id, progress) => {
-        getWindowById(id).setProgressBar(progress);
+        getWindowById(id)?.setProgressBar(progress);
     });
     socket.on('browserWindowSetProgressBar', (id, progress, options) => {
-        getWindowById(id).setProgressBar(progress, options);
+        getWindowById(id)?.setProgressBar(progress, options);
     });
     socket.on('browserWindowSetHasShadow', (id, hasShadow) => {
-        getWindowById(id).setHasShadow(hasShadow);
+        getWindowById(id)?.setHasShadow(hasShadow);
     });
     socket.on('browserWindowHasShadow', (id) => {
-        const hasShadow = getWindowById(id).hasShadow();
-        electronSocket.emit('browserWindow-hasShadow-completed', hasShadow);
+        const hasShadow = getWindowById(id)?.hasShadow() ?? null;
+        electronSocket.emit('browserWindow-hasShadow-completed' + id, hasShadow);
     });
     socket.on('browserWindowSetThumbarButtons', (id, thumbarButtons) => {
         thumbarButtons.forEach(thumbarButton => {
@@ -528,75 +542,75 @@ module.exports = (socket, app) => {
                 electronSocket.emit('thumbarButtonClicked', thumbarButton['id']);
             };
         });
-        const success = getWindowById(id).setThumbarButtons(thumbarButtons);
-        electronSocket.emit('browserWindowSetThumbarButtons-completed', success);
+        const success = getWindowById(id)?.setThumbarButtons(thumbarButtons) ?? null;
+        electronSocket.emit('browserWindowSetThumbarButtons-completed' + id, success);
     });
     socket.on('browserWindowSetThumbnailClip', (id, rectangle) => {
-        getWindowById(id).setThumbnailClip(rectangle);
+        getWindowById(id)?.setThumbnailClip(rectangle);
     });
     socket.on('browserWindowSetThumbnailToolTip', (id, toolTip) => {
-        getWindowById(id).setThumbnailToolTip(toolTip);
+        getWindowById(id)?.setThumbnailToolTip(toolTip);
     });
     socket.on('browserWindowSetAppDetails', (id, options) => {
-        getWindowById(id).setAppDetails(options);
+        getWindowById(id)?.setAppDetails(options);
     });
     socket.on('browserWindowShowDefinitionForSelection', (id) => {
-        getWindowById(id).showDefinitionForSelection();
+        getWindowById(id)?.showDefinitionForSelection();
     });
     socket.on('browserWindowSetAutoHideMenuBar', (id, hide) => {
-        getWindowById(id).setAutoHideMenuBar(hide);
+        getWindowById(id)?.setAutoHideMenuBar(hide);
     });
     socket.on('browserWindowIsMenuBarAutoHide', (id) => {
-        const isMenuBarAutoHide = getWindowById(id).isMenuBarAutoHide();
-        electronSocket.emit('browserWindow-isMenuBarAutoHide-completed', isMenuBarAutoHide);
+        const isMenuBarAutoHide = getWindowById(id)?.isMenuBarAutoHide() ?? null;
+        electronSocket.emit('browserWindow-isMenuBarAutoHide-completed' + id, isMenuBarAutoHide);
     });
     socket.on('browserWindowSetMenuBarVisibility', (id, visible) => {
-        getWindowById(id).setMenuBarVisibility(visible);
+        getWindowById(id)?.setMenuBarVisibility(visible);
     });
     socket.on('browserWindowIsMenuBarVisible', (id) => {
-        const isMenuBarVisible = getWindowById(id).isMenuBarVisible();
-        electronSocket.emit('browserWindow-isMenuBarVisible-completed', isMenuBarVisible);
+        const isMenuBarVisible = getWindowById(id)?.isMenuBarVisible() ?? null;
+        electronSocket.emit('browserWindow-isMenuBarVisible-completed' + id, isMenuBarVisible);
     });
     socket.on('browserWindowSetVisibleOnAllWorkspaces', (id, visible) => {
-        getWindowById(id).setVisibleOnAllWorkspaces(visible);
+        getWindowById(id)?.setVisibleOnAllWorkspaces(visible);
     });
     socket.on('browserWindowIsVisibleOnAllWorkspaces', (id) => {
-        const isVisibleOnAllWorkspaces = getWindowById(id).isVisibleOnAllWorkspaces();
-        electronSocket.emit('browserWindow-isVisibleOnAllWorkspaces-completed', isVisibleOnAllWorkspaces);
+        const isVisibleOnAllWorkspaces = getWindowById(id)?.isVisibleOnAllWorkspaces() ?? null;
+        electronSocket.emit('browserWindow-isVisibleOnAllWorkspaces-completed' + id, isVisibleOnAllWorkspaces);
     });
     socket.on('browserWindowSetIgnoreMouseEvents', (id, ignore) => {
-        getWindowById(id).setIgnoreMouseEvents(ignore);
+        getWindowById(id)?.setIgnoreMouseEvents(ignore);
     });
     socket.on('browserWindowSetContentProtection', (id, enable) => {
-        getWindowById(id).setContentProtection(enable);
+        getWindowById(id)?.setContentProtection(enable);
     });
     socket.on('browserWindowSetFocusable', (id, focusable) => {
-        getWindowById(id).setFocusable(focusable);
+        getWindowById(id)?.setFocusable(focusable);
     });
     socket.on('browserWindowSetParentWindow', (id, parent) => {
         const browserWindow = electron_1.BrowserWindow.fromId(parent.id);
-        getWindowById(id).setParentWindow(browserWindow);
+        getWindowById(id)?.setParentWindow(browserWindow);
     });
     socket.on('browserWindowGetParentWindow', (id) => {
-        const browserWindow = getWindowById(id).getParentWindow();
-        electronSocket.emit('browserWindow-getParentWindow-completed', browserWindow.id);
+        const browserWindow = getWindowById(id)?.getParentWindow() ?? null;
+        electronSocket.emit('browserWindow-getParentWindow-completed' + id, browserWindow.id);
     });
     socket.on('browserWindowGetChildWindows', (id) => {
-        const browserWindows = getWindowById(id).getChildWindows();
+        const browserWindows = getWindowById(id)?.getChildWindows() ?? null;
         const ids = [];
         browserWindows.forEach(x => {
             ids.push(x.id);
         });
-        electronSocket.emit('browserWindow-getChildWindows-completed', ids);
+        electronSocket.emit('browserWindow-getChildWindows-completed' + id, ids);
     });
     socket.on('browserWindowSetAutoHideCursor', (id, autoHide) => {
-        getWindowById(id).setAutoHideCursor(autoHide);
+        getWindowById(id)?.setAutoHideCursor(autoHide);
     });
     socket.on('browserWindowSetVibrancy', (id, type) => {
-        getWindowById(id).setVibrancy(type);
+        getWindowById(id)?.setVibrancy(type);
     });
     socket.on('browserWindow-setBrowserView', (id, browserViewId) => {
-        getWindowById(id).setBrowserView(browserView_1.browserViewMediateService(browserViewId));
+        getWindowById(id)?.setBrowserView(browserView_1.browserViewMediateService(browserViewId));
     });
     function getWindowById(id) {
         for (let index = 0; index < windows.length; index++) {
@@ -605,6 +619,7 @@ module.exports = (socket, app) => {
                 return element;
             }
         }
+        return null;
     }
 };
 //# sourceMappingURL=browserWindows.js.map

ElectronNET.Host/api/browserWindows.ts

@@ -29,182 +29,182 @@ export = (socket: Socket, app: Electron.App) => {
             electronSocket.emit('browserWindow-ready-to-show' + id);
         }
 
-        getWindowById(id).on('ready-to-show', () => {
+        getWindowById(id)?.on('ready-to-show', () => {
             readyToShowWindowsIds.push(id);
             electronSocket.emit('browserWindow-ready-to-show' + id);
         });
     });
 
     socket.on('register-browserWindow-page-title-updated', (id) => {
-        getWindowById(id).on('page-title-updated', (event, title) => {
+        getWindowById(id)?.on('page-title-updated', (event, title) => {
             electronSocket.emit('browserWindow-page-title-updated' + id, title);
         });
     });
 
     socket.on('register-browserWindow-close', (id) => {
-        getWindowById(id).on('close', () => {
+        getWindowById(id)?.on('close', () => {
             electronSocket.emit('browserWindow-close' + id);
         });
     });
 
     socket.on('register-browserWindow-closed', (id) => {
-        getWindowById(id).on('closed', () => {
+        getWindowById(id)?.on('closed', () => {
             electronSocket.emit('browserWindow-closed' + id);
         });
     });
 
     socket.on('register-browserWindow-session-end', (id) => {
-        getWindowById(id).on('session-end', () => {
+        getWindowById(id)?.on('session-end', () => {
             electronSocket.emit('browserWindow-session-end' + id);
         });
     });
 
     socket.on('register-browserWindow-unresponsive', (id) => {
-        getWindowById(id).on('unresponsive', () => {
+        getWindowById(id)?.on('unresponsive', () => {
             electronSocket.emit('browserWindow-unresponsive' + id);
         });
     });
 
     socket.on('register-browserWindow-responsive', (id) => {
-        getWindowById(id).on('responsive', () => {
+        getWindowById(id)?.on('responsive', () => {
             electronSocket.emit('browserWindow-responsive' + id);
         });
     });
 
     socket.on('register-browserWindow-blur', (id) => {
-        getWindowById(id).on('blur', () => {
+        getWindowById(id)?.on('blur', () => {
             electronSocket.emit('browserWindow-blur' + id);
         });
     });
 
     socket.on('register-browserWindow-focus', (id) => {
-        getWindowById(id).on('focus', () => {
+        getWindowById(id)?.on('focus', () => {
             electronSocket.emit('browserWindow-focus' + id);
         });
     });
 
     socket.on('register-browserWindow-show', (id) => {
-        getWindowById(id).on('show', () => {
+        getWindowById(id)?.on('show', () => {
             electronSocket.emit('browserWindow-show' + id);
         });
     });
 
     socket.on('register-browserWindow-hide', (id) => {
-        getWindowById(id).on('hide', () => {
+        getWindowById(id)?.on('hide', () => {
             electronSocket.emit('browserWindow-hide' + id);
         });
     });
 
     socket.on('register-browserWindow-maximize', (id) => {
-        getWindowById(id).on('maximize', () => {
+        getWindowById(id)?.on('maximize', () => {
             electronSocket.emit('browserWindow-maximize' + id);
         });
     });
 
     socket.on('register-browserWindow-unmaximize', (id) => {
-        getWindowById(id).on('unmaximize', () => {
+        getWindowById(id)?.on('unmaximize', () => {
             electronSocket.emit('browserWindow-unmaximize' + id);
         });
     });
 
     socket.on('register-browserWindow-minimize', (id) => {
-        getWindowById(id).on('minimize', () => {
+        getWindowById(id)?.on('minimize', () => {
             electronSocket.emit('browserWindow-minimize' + id);
         });
     });
 
     socket.on('register-browserWindow-restore', (id) => {
-        getWindowById(id).on('restore', () => {
+        getWindowById(id)?.on('restore', () => {
             electronSocket.emit('browserWindow-restore' + id);
         });
     });
 
     socket.on('register-browserWindow-resize', (id) => {
-        getWindowById(id).on('resize', () => {
+        getWindowById(id)?.on('resize', () => {
             electronSocket.emit('browserWindow-resize' + id);
         });
     });
 
     socket.on('register-browserWindow-move', (id) => {
-        getWindowById(id).on('move', () => {
+        getWindowById(id)?.on('move', () => {
             electronSocket.emit('browserWindow-move' + id);
         });
     });
 
     socket.on('register-browserWindow-moved', (id) => {
-        getWindowById(id).on('moved', () => {
+        getWindowById(id)?.on('moved', () => {
             electronSocket.emit('browserWindow-moved' + id);
         });
     });
 
     socket.on('register-browserWindow-enter-full-screen', (id) => {
-        getWindowById(id).on('enter-full-screen', () => {
+        getWindowById(id)?.on('enter-full-screen', () => {
             electronSocket.emit('browserWindow-enter-full-screen' + id);
         });
     });
 
     socket.on('register-browserWindow-leave-full-screen', (id) => {
-        getWindowById(id).on('leave-full-screen', () => {
+        getWindowById(id)?.on('leave-full-screen', () => {
             electronSocket.emit('browserWindow-leave-full-screen' + id);
         });
     });
 
     socket.on('register-browserWindow-enter-html-full-screen', (id) => {
-        getWindowById(id).on('enter-html-full-screen', () => {
+        getWindowById(id)?.on('enter-html-full-screen', () => {
             electronSocket.emit('browserWindow-enter-html-full-screen' + id);
         });
     });
 
     socket.on('register-browserWindow-leave-html-full-screen', (id) => {
-        getWindowById(id).on('leave-html-full-screen', () => {
+        getWindowById(id)?.on('leave-html-full-screen', () => {
             electronSocket.emit('browserWindow-leave-html-full-screen' + id);
         });
     });
 
     socket.on('register-browserWindow-app-command', (id) => {
-        getWindowById(id).on('app-command', (event, command) => {
+        getWindowById(id)?.on('app-command', (event, command) => {
             electronSocket.emit('browserWindow-app-command' + id, command);
         });
     });
 
     socket.on('register-browserWindow-scroll-touch-begin', (id) => {
-        getWindowById(id).on('scroll-touch-begin', () => {
+        getWindowById(id)?.on('scroll-touch-begin', () => {
             electronSocket.emit('browserWindow-scroll-touch-begin' + id);
         });
     });
 
     socket.on('register-browserWindow-scroll-touch-end', (id) => {
-        getWindowById(id).on('scroll-touch-end', () => {
+        getWindowById(id)?.on('scroll-touch-end', () => {
             electronSocket.emit('browserWindow-scroll-touch-end' + id);
         });
     });
 
     socket.on('register-browserWindow-scroll-touch-edge', (id) => {
-        getWindowById(id).on('scroll-touch-edge', () => {
+        getWindowById(id)?.on('scroll-touch-edge', () => {
             electronSocket.emit('browserWindow-scroll-touch-edge' + id);
         });
     });
 
     socket.on('register-browserWindow-swipe', (id) => {
-        getWindowById(id).on('swipe', (event, direction) => {
+        getWindowById(id)?.on('swipe', (event, direction) => {
             electronSocket.emit('browserWindow-swipe' + id, direction);
         });
     });
 
     socket.on('register-browserWindow-sheet-begin', (id) => {
-        getWindowById(id).on('sheet-begin', () => {
+        getWindowById(id)?.on('sheet-begin', () => {
             electronSocket.emit('browserWindow-sheet-begin' + id);
         });
     });
 
     socket.on('register-browserWindow-sheet-end', (id) => {
-        getWindowById(id).on('sheet-end', () => {
+        getWindowById(id)?.on('sheet-end', () => {
             electronSocket.emit('browserWindow-sheet-end' + id);
         });
     });
 
     socket.on('register-browserWindow-new-window-for-tab', (id) => {
-        getWindowById(id).on('new-window-for-tab', () => {
+        getWindowById(id)?.on('new-window-for-tab', () => {
             electronSocket.emit('browserWindow-new-window-for-tab' + id);
         });
     });
@@ -293,330 +293,334 @@ export = (socket: Socket, app: Electron.App) => {
     });
 
     socket.on('browserWindowDestroy', (id) => {
-        getWindowById(id).destroy();
+        getWindowById(id)?.destroy();
     });
 
     socket.on('browserWindowClose', (id) => {
-        getWindowById(id).close();
+        getWindowById(id)?.close();
     });
 
     socket.on('browserWindowFocus', (id) => {
-        getWindowById(id).focus();
+        getWindowById(id)?.focus();
     });
 
     socket.on('browserWindowBlur', (id) => {
-        getWindowById(id).blur();
+        getWindowById(id)?.blur();
     });
 
     socket.on('browserWindowIsFocused', (id) => {
-        const isFocused = getWindowById(id).isFocused();
+        const isFocused = getWindowById(id)?.isFocused() ?? null;
 
-        electronSocket.emit('browserWindow-isFocused-completed', isFocused);
+        electronSocket.emit('browserWindow-isFocused-completed' + id, isFocused);
     });
 
     socket.on('browserWindowIsDestroyed', (id) => {
-        const isDestroyed = getWindowById(id).isDestroyed();
-
-        electronSocket.emit('browserWindow-isDestroyed-completed', isDestroyed);
+        const w = getWindowById(id);
+        if (w) {
+            const isDestroyed = w.isDestroyed();
+            electronSocket.emit('browserWindow-isDestroyed-completed' + id, isDestroyed);
+        } else {
+            electronSocket.emit('browserWindow-isDestroyed-completed' + id, true);
+        }
     });
 
     socket.on('browserWindowShow', (id) => {
-        getWindowById(id).show();
+        getWindowById(id)?.show();
     });
 
     socket.on('browserWindowShowInactive', (id) => {
-        getWindowById(id).showInactive();
+        getWindowById(id)?.showInactive();
     });
 
     socket.on('browserWindowHide', (id) => {
-        getWindowById(id).hide();
+        getWindowById(id)?.hide();
     });
 
     socket.on('browserWindowIsVisible', (id) => {
-        const isVisible = getWindowById(id).isVisible();
+        const isVisible = getWindowById(id)?.isVisible() ?? null;
 
-        electronSocket.emit('browserWindow-isVisible-completed', isVisible);
+        electronSocket.emit('browserWindow-isVisible-completed' + id, isVisible);
     });
 
     socket.on('browserWindowIsModal', (id) => {
-        const isModal = getWindowById(id).isModal();
+        const isModal = getWindowById(id)?.isModal() ?? null;
 
-        electronSocket.emit('browserWindow-isModal-completed', isModal);
+        electronSocket.emit('browserWindow-isModal-completed' + id, isModal);
     });
 
     socket.on('browserWindowMaximize', (id) => {
-        getWindowById(id).maximize();
+        getWindowById(id)?.maximize();
     });
 
     socket.on('browserWindowUnmaximize', (id) => {
-        getWindowById(id).unmaximize();
+        getWindowById(id)?.unmaximize();
     });
 
     socket.on('browserWindowIsMaximized', (id) => {
-        const isMaximized = getWindowById(id).isMaximized();
+        const isMaximized = getWindowById(id)?.isMaximized() ?? null;
 
-        electronSocket.emit('browserWindow-isMaximized-completed', isMaximized);
+        electronSocket.emit('browserWindow-isMaximized-completed' + id, isMaximized);
     });
 
     socket.on('browserWindowMinimize', (id) => {
-        getWindowById(id).minimize();
+        getWindowById(id)?.minimize();
     });
 
     socket.on('browserWindowRestore', (id) => {
-        getWindowById(id).restore();
+        getWindowById(id)?.restore();
     });
 
     socket.on('browserWindowIsMinimized', (id) => {
-        const isMinimized = getWindowById(id).isMinimized();
+        const isMinimized = getWindowById(id)?.isMinimized() ?? null;
 
-        electronSocket.emit('browserWindow-isMinimized-completed', isMinimized);
+        electronSocket.emit('browserWindow-isMinimized-completed' + id, isMinimized);
     });
 
     socket.on('browserWindowSetFullScreen', (id, fullscreen) => {
-        getWindowById(id).setFullScreen(fullscreen);
+        getWindowById(id)?.setFullScreen(fullscreen);
     });
 
     socket.on('browserWindowIsFullScreen', (id) => {
-        const isFullScreen = getWindowById(id).isFullScreen();
+        const isFullScreen = getWindowById(id)?.isFullScreen() ?? null;
 
-        electronSocket.emit('browserWindow-isFullScreen-completed', isFullScreen);
+        electronSocket.emit('browserWindow-isFullScreen-completed' + id, isFullScreen);
     });
 
     socket.on('browserWindowSetAspectRatio', (id, aspectRatio, extraSize) => {
-        getWindowById(id).setAspectRatio(aspectRatio, extraSize);
+        getWindowById(id)?.setAspectRatio(aspectRatio, extraSize);
     });
 
     socket.on('browserWindowPreviewFile', (id, path, displayname) => {
-        getWindowById(id).previewFile(path, displayname);
+        getWindowById(id)?.previewFile(path, displayname);
     });
 
     socket.on('browserWindowCloseFilePreview', (id) => {
-        getWindowById(id).closeFilePreview();
+        getWindowById(id)?.closeFilePreview();
     });
 
     socket.on('browserWindowSetBounds', (id, bounds, animate) => {
-        getWindowById(id).setBounds(bounds, animate);
+        getWindowById(id)?.setBounds(bounds, animate);
     });
 
     socket.on('browserWindowGetBounds', (id) => {
-        const rectangle = getWindowById(id).getBounds();
+        const rectangle = getWindowById(id)?.getBounds() ?? null;
 
-        electronSocket.emit('browserWindow-getBounds-completed', rectangle);
+        electronSocket.emit('browserWindow-getBounds-completed' + id, rectangle);
     });
 
     socket.on('browserWindowSetContentBounds', (id, bounds, animate) => {
-        getWindowById(id).setContentBounds(bounds, animate);
+        getWindowById(id)?.setContentBounds(bounds, animate);
     });
 
     socket.on('browserWindowGetContentBounds', (id) => {
-        const rectangle = getWindowById(id).getContentBounds();
+        const rectangle = getWindowById(id)?.getContentBounds() ?? null;
 
-        electronSocket.emit('browserWindow-getContentBounds-completed', rectangle);
+        electronSocket.emit('browserWindow-getContentBounds-completed' + id, rectangle);
     });
 
     socket.on('browserWindowSetSize', (id, width, height, animate) => {
-        getWindowById(id).setSize(width, height, animate);
+        getWindowById(id)?.setSize(width, height, animate);
     });
 
     socket.on('browserWindowGetSize', (id) => {
-        const size = getWindowById(id).getSize();
+        const size = getWindowById(id)?.getSize() ?? null;
 
-        electronSocket.emit('browserWindow-getSize-completed', size);
+        electronSocket.emit('browserWindow-getSize-completed' + id, size);
     });
 
     socket.on('browserWindowSetContentSize', (id, width, height, animate) => {
-        getWindowById(id).setContentSize(width, height, animate);
+        getWindowById(id)?.setContentSize(width, height, animate);
     });
 
     socket.on('browserWindowGetContentSize', (id) => {
-        const size = getWindowById(id).getContentSize();
+        const size = getWindowById(id)?.getContentSize() ?? null;
 
-        electronSocket.emit('browserWindow-getContentSize-completed', size);
+        electronSocket.emit('browserWindow-getContentSize-completed' + id, size);
     });
 
     socket.on('browserWindowSetMinimumSize', (id, width, height) => {
-        getWindowById(id).setMinimumSize(width, height);
+        getWindowById(id)?.setMinimumSize(width, height);
     });
 
     socket.on('browserWindowGetMinimumSize', (id) => {
-        const size = getWindowById(id).getMinimumSize();
+        const size = getWindowById(id)?.getMinimumSize() ?? null;
 
-        electronSocket.emit('browserWindow-getMinimumSize-completed', size);
+        electronSocket.emit('browserWindow-getMinimumSize-completed' + id, size);
     });
 
     socket.on('browserWindowSetMaximumSize', (id, width, height) => {
-        getWindowById(id).setMaximumSize(width, height);
+        getWindowById(id)?.setMaximumSize(width, height);
     });
 
     socket.on('browserWindowGetMaximumSize', (id) => {
-        const size = getWindowById(id).getMaximumSize();
+        const size = getWindowById(id)?.getMaximumSize() ?? null;
 
-        electronSocket.emit('browserWindow-getMaximumSize-completed', size);
+        electronSocket.emit('browserWindow-getMaximumSize-completed' + id, size);
     });
 
     socket.on('browserWindowSetResizable', (id, resizable) => {
-        getWindowById(id).setResizable(resizable);
+        getWindowById(id)?.setResizable(resizable);
     });
 
     socket.on('browserWindowIsResizable', (id) => {
-        const resizable = getWindowById(id).isResizable();
+        const resizable = getWindowById(id)?.isResizable() ?? null;
 
-        electronSocket.emit('browserWindow-isResizable-completed', resizable);
+        electronSocket.emit('browserWindow-isResizable-completed' + id, resizable);
     });
 
     socket.on('browserWindowSetMovable', (id, movable) => {
-        getWindowById(id).setMovable(movable);
+        getWindowById(id)?.setMovable(movable);
     });
 
     socket.on('browserWindowIsMovable', (id) => {
-        const movable = getWindowById(id).isMovable();
+        const movable = getWindowById(id)?.isMovable() ?? null;
 
-        electronSocket.emit('browserWindow-isMovable-completed', movable);
+        electronSocket.emit('browserWindow-isMovable-completed' + id, movable);
     });
 
     socket.on('browserWindowSetMinimizable', (id, minimizable) => {
-        getWindowById(id).setMinimizable(minimizable);
+        getWindowById(id)?.setMinimizable(minimizable);
     });
 
     socket.on('browserWindowIsMinimizable', (id) => {
-        const minimizable = getWindowById(id).isMinimizable();
+        const minimizable = getWindowById(id)?.isMinimizable() ?? null;
 
-        electronSocket.emit('browserWindow-isMinimizable-completed', minimizable);
+        electronSocket.emit('browserWindow-isMinimizable-completed' + id, minimizable);
     });
 
     socket.on('browserWindowSetMaximizable', (id, maximizable) => {
-        getWindowById(id).setMaximizable(maximizable);
+        getWindowById(id)?.setMaximizable(maximizable);
     });
 
     socket.on('browserWindowIsMaximizable', (id) => {
-        const maximizable = getWindowById(id).isMaximizable();
+        const maximizable = getWindowById(id)?.isMaximizable() ?? null;
 
-        electronSocket.emit('browserWindow-isMaximizable-completed', maximizable);
+        electronSocket.emit('browserWindow-isMaximizable-completed' + id, maximizable);
     });
 
     socket.on('browserWindowSetFullScreenable', (id, fullscreenable) => {
-        getWindowById(id).setFullScreenable(fullscreenable);
+        getWindowById(id)?.setFullScreenable(fullscreenable);
     });
 
     socket.on('browserWindowIsFullScreenable', (id) => {
-        const fullscreenable = getWindowById(id).isFullScreenable();
+        const fullscreenable = getWindowById(id)?.isFullScreenable() ?? null;
 
-        electronSocket.emit('browserWindow-isFullScreenable-completed', fullscreenable);
+        electronSocket.emit('browserWindow-isFullScreenable-completed' + id, fullscreenable);
     });
 
     socket.on('browserWindowSetClosable', (id, closable) => {
-        getWindowById(id).setClosable(closable);
+        getWindowById(id)?.setClosable(closable);
     });
 
     socket.on('browserWindowIsClosable', (id) => {
-        const closable = getWindowById(id).isClosable();
+        const closable = getWindowById(id)?.isClosable() ?? null;
 
-        electronSocket.emit('browserWindow-isClosable-completed', closable);
+        electronSocket.emit('browserWindow-isClosable-completed' + id, closable);
     });
 
     socket.on('browserWindowSetAlwaysOnTop', (id, flag, level, relativeLevel) => {
-        getWindowById(id).setAlwaysOnTop(flag, level, relativeLevel);
+        getWindowById(id)?.setAlwaysOnTop(flag, level, relativeLevel);
     });
 
     socket.on('browserWindowIsAlwaysOnTop', (id) => {
-        const isAlwaysOnTop = getWindowById(id).isAlwaysOnTop();
+        const isAlwaysOnTop = getWindowById(id)?.isAlwaysOnTop() ?? null;
 
-        electronSocket.emit('browserWindow-isAlwaysOnTop-completed', isAlwaysOnTop);
+        electronSocket.emit('browserWindow-isAlwaysOnTop-completed' + id, isAlwaysOnTop);
     });
 
     socket.on('browserWindowCenter', (id) => {
-        getWindowById(id).center();
+        getWindowById(id)?.center();
     });
 
     socket.on('browserWindowSetPosition', (id, x, y, animate) => {
-        getWindowById(id).setPosition(x, y, animate);
+        getWindowById(id)?.setPosition(x, y, animate);
     });
 
     socket.on('browserWindowGetPosition', (id) => {
-        const position = getWindowById(id).getPosition();
+        const position = getWindowById(id)?.getPosition() ?? null;
 
-        electronSocket.emit('browserWindow-getPosition-completed', position);
+        electronSocket.emit('browserWindow-getPosition-completed' + id, position);
     });
 
     socket.on('browserWindowSetTitle', (id, title) => {
-        getWindowById(id).setTitle(title);
+        getWindowById(id)?.setTitle(title);
     });
 
     socket.on('browserWindowGetTitle', (id) => {
-        const title = getWindowById(id).getTitle();
+        const title = getWindowById(id)?.getTitle() ?? null;
 
-        electronSocket.emit('browserWindow-getTitle-completed', title);
+        electronSocket.emit('browserWindow-getTitle-completed' + id, title);
     });
 
     socket.on('browserWindowSetTitle', (id, title) => {
-        getWindowById(id).setTitle(title);
+        getWindowById(id)?.setTitle(title);
     });
 
     socket.on('browserWindowSetSheetOffset', (id, offsetY, offsetX) => {
         if (offsetX) {
-            getWindowById(id).setSheetOffset(offsetY, offsetX);
+            getWindowById(id)?.setSheetOffset(offsetY, offsetX);
         } else {
-            getWindowById(id).setSheetOffset(offsetY);
+            getWindowById(id)?.setSheetOffset(offsetY);
         }
     });
 
     socket.on('browserWindowFlashFrame', (id, flag) => {
-        getWindowById(id).flashFrame(flag);
+        getWindowById(id)?.flashFrame(flag);
     });
 
     socket.on('browserWindowSetSkipTaskbar', (id, skip) => {
-        getWindowById(id).setSkipTaskbar(skip);
+        getWindowById(id)?.setSkipTaskbar(skip);
     });
 
     socket.on('browserWindowSetKiosk', (id, flag) => {
-        getWindowById(id).setKiosk(flag);
+        getWindowById(id)?.setKiosk(flag);
     });
 
     socket.on('browserWindowIsKiosk', (id) => {
-        const isKiosk = getWindowById(id).isKiosk();
+        const isKiosk = getWindowById(id)?.isKiosk() ?? null;
 
-        electronSocket.emit('browserWindow-isKiosk-completed', isKiosk);
+        electronSocket.emit('browserWindow-isKiosk-completed' + id, isKiosk);
     });
 
     socket.on('browserWindowGetNativeWindowHandle', (id) => {
-        const nativeWindowHandle = getWindowById(id).getNativeWindowHandle().readInt32LE(0).toString(16);
-        electronSocket.emit('browserWindow-getNativeWindowHandle-completed', nativeWindowHandle);
+        const nativeWindowHandle = getWindowById(id)?.getNativeWindowHandle()?.readInt32LE(0)?.toString(16) ?? null;
+        electronSocket.emit('browserWindow-getNativeWindowHandle-completed' + id, nativeWindowHandle);
     });
 
     socket.on('browserWindowSetRepresentedFilename', (id, filename) => {
-        getWindowById(id).setRepresentedFilename(filename);
+        getWindowById(id)?.setRepresentedFilename(filename);
     });
 
     socket.on('browserWindowGetRepresentedFilename', (id) => {
-        const pathname = getWindowById(id).getRepresentedFilename();
+        const pathname = getWindowById(id)?.getRepresentedFilename() ?? null;
 
-        electronSocket.emit('browserWindow-getRepresentedFilename-completed', pathname);
+        electronSocket.emit('browserWindow-getRepresentedFilename-completed' + id, pathname);
     });
 
     socket.on('browserWindowSetDocumentEdited', (id, edited) => {
-        getWindowById(id).setDocumentEdited(edited);
+        getWindowById(id)?.setDocumentEdited(edited);
     });
 
     socket.on('browserWindowIsDocumentEdited', (id) => {
-        const edited = getWindowById(id).isDocumentEdited();
+        const edited = getWindowById(id)?.isDocumentEdited() ?? null;
 
-        electronSocket.emit('browserWindow-isDocumentEdited-completed', edited);
+        electronSocket.emit('browserWindow-isDocumentEdited-completed' + id, edited);
     });
 
     socket.on('browserWindowFocusOnWebView', (id) => {
-        getWindowById(id).focusOnWebView();
+        getWindowById(id)?.focusOnWebView();
     });
 
     socket.on('browserWindowBlurWebView', (id) => {
-        getWindowById(id).blurWebView();
+        getWindowById(id)?.blurWebView();
     });
 
     socket.on('browserWindowLoadURL', (id, url, options) => {
-        getWindowById(id).loadURL(url, options);
+        getWindowById(id)?.loadURL(url, options);
     });
 
     socket.on('browserWindowReload', (id) => {
-        getWindowById(id).reload();
+        getWindowById(id)?.reload();
     });
 
     socket.on('browserWindowSetMenu', (id, menuItems) => {
@@ -630,11 +634,11 @@ export = (socket: Socket, app: Electron.App) => {
             });
         }
 
-        getWindowById(id).setMenu(menu);
+        getWindowById(id)?.setMenu(menu);
     });
 
     socket.on('browserWindowRemoveMenu', (id) => {
-        getWindowById(id).removeMenu();
+        getWindowById(id)?.removeMenu();
     });
 
     function addMenuItemClickConnector(menuItems, callback) {
@@ -650,21 +654,21 @@ export = (socket: Socket, app: Electron.App) => {
     }
 
     socket.on('browserWindowSetProgressBar', (id, progress) => {
-        getWindowById(id).setProgressBar(progress);
+        getWindowById(id)?.setProgressBar(progress);
     });
 
     socket.on('browserWindowSetProgressBar', (id, progress, options) => {
-        getWindowById(id).setProgressBar(progress, options);
+        getWindowById(id)?.setProgressBar(progress, options);
     });
 
     socket.on('browserWindowSetHasShadow', (id, hasShadow) => {
-        getWindowById(id).setHasShadow(hasShadow);
+        getWindowById(id)?.setHasShadow(hasShadow);
     });
 
     socket.on('browserWindowHasShadow', (id) => {
-        const hasShadow = getWindowById(id).hasShadow();
+        const hasShadow = getWindowById(id)?.hasShadow() ?? null;
 
-        electronSocket.emit('browserWindow-hasShadow-completed', hasShadow);
+        electronSocket.emit('browserWindow-hasShadow-completed' + id, hasShadow);
     });
 
     socket.on('browserWindowSetThumbarButtons', (id, thumbarButtons: Electron.ThumbarButton[]) => {
@@ -676,82 +680,82 @@ export = (socket: Socket, app: Electron.App) => {
             };
         });
 
-        const success = getWindowById(id).setThumbarButtons(thumbarButtons);
-        electronSocket.emit('browserWindowSetThumbarButtons-completed', success);
+        const success = getWindowById(id)?.setThumbarButtons(thumbarButtons) ?? null;
+        electronSocket.emit('browserWindowSetThumbarButtons-completed' + id, success);
     });
 
     socket.on('browserWindowSetThumbnailClip', (id, rectangle) => {
-        getWindowById(id).setThumbnailClip(rectangle);
+        getWindowById(id)?.setThumbnailClip(rectangle);
     });
 
     socket.on('browserWindowSetThumbnailToolTip', (id, toolTip) => {
-        getWindowById(id).setThumbnailToolTip(toolTip);
+        getWindowById(id)?.setThumbnailToolTip(toolTip);
     });
 
     socket.on('browserWindowSetAppDetails', (id, options) => {
-        getWindowById(id).setAppDetails(options);
+        getWindowById(id)?.setAppDetails(options);
     });
 
     socket.on('browserWindowShowDefinitionForSelection', (id) => {
-        getWindowById(id).showDefinitionForSelection();
+        getWindowById(id)?.showDefinitionForSelection();
     });
 
     socket.on('browserWindowSetAutoHideMenuBar', (id, hide) => {
-        getWindowById(id).setAutoHideMenuBar(hide);
+        getWindowById(id)?.setAutoHideMenuBar(hide);
     });
 
     socket.on('browserWindowIsMenuBarAutoHide', (id) => {
-        const isMenuBarAutoHide = getWindowById(id).isMenuBarAutoHide();
+        const isMenuBarAutoHide = getWindowById(id)?.isMenuBarAutoHide() ?? null;
 
-        electronSocket.emit('browserWindow-isMenuBarAutoHide-completed', isMenuBarAutoHide);
+        electronSocket.emit('browserWindow-isMenuBarAutoHide-completed' + id, isMenuBarAutoHide);
     });
 
     socket.on('browserWindowSetMenuBarVisibility', (id, visible) => {
-        getWindowById(id).setMenuBarVisibility(visible);
+        getWindowById(id)?.setMenuBarVisibility(visible);
     });
 
     socket.on('browserWindowIsMenuBarVisible', (id) => {
-        const isMenuBarVisible = getWindowById(id).isMenuBarVisible();
+        const isMenuBarVisible = getWindowById(id)?.isMenuBarVisible() ?? null;
 
-        electronSocket.emit('browserWindow-isMenuBarVisible-completed', isMenuBarVisible);
+        electronSocket.emit('browserWindow-isMenuBarVisible-completed' + id, isMenuBarVisible);
     });
 
     socket.on('browserWindowSetVisibleOnAllWorkspaces', (id, visible) => {
-        getWindowById(id).setVisibleOnAllWorkspaces(visible);
+        getWindowById(id)?.setVisibleOnAllWorkspaces(visible);
     });
 
     socket.on('browserWindowIsVisibleOnAllWorkspaces', (id) => {
-        const isVisibleOnAllWorkspaces = getWindowById(id).isVisibleOnAllWorkspaces();
+        const isVisibleOnAllWorkspaces = getWindowById(id)?.isVisibleOnAllWorkspaces() ?? null;
 
-        electronSocket.emit('browserWindow-isVisibleOnAllWorkspaces-completed', isVisibleOnAllWorkspaces);
+        electronSocket.emit('browserWindow-isVisibleOnAllWorkspaces-completed' + id, isVisibleOnAllWorkspaces);
     });
 
     socket.on('browserWindowSetIgnoreMouseEvents', (id, ignore) => {
-        getWindowById(id).setIgnoreMouseEvents(ignore);
+        getWindowById(id)?.setIgnoreMouseEvents(ignore);
     });
 
     socket.on('browserWindowSetContentProtection', (id, enable) => {
-        getWindowById(id).setContentProtection(enable);
+        getWindowById(id)?.setContentProtection(enable);
     });
 
     socket.on('browserWindowSetFocusable', (id, focusable) => {
-        getWindowById(id).setFocusable(focusable);
+        getWindowById(id)?.setFocusable(focusable);
     });
 
     socket.on('browserWindowSetParentWindow', (id, parent) => {
         const browserWindow = BrowserWindow.fromId(parent.id);
 
-        getWindowById(id).setParentWindow(browserWindow);
+        getWindowById(id)?.setParentWindow(browserWindow);
     });
 
     socket.on('browserWindowGetParentWindow', (id) => {
-        const browserWindow = getWindowById(id).getParentWindow();
+        const browserWindow = getWindowById(id)?.getParentWindow() ?? null;
 
-        electronSocket.emit('browserWindow-getParentWindow-completed', browserWindow.id);
+        electronSocket.emit('browserWindow-getParentWindow-completed' + id, browserWindow.id);
     });
 
     socket.on('browserWindowGetChildWindows', (id) => {
-        const browserWindows = getWindowById(id).getChildWindows();
+        const browserWindows = getWindowById(id)?.getChildWindows() ?? null;
 
         const ids = [];
 
@@ -759,19 +763,19 @@ export = (socket: Socket, app: Electron.App) => {
             ids.push(x.id);
         });
 
-        electronSocket.emit('browserWindow-getChildWindows-completed', ids);
+        electronSocket.emit('browserWindow-getChildWindows-completed' + id, ids);
     });
 
     socket.on('browserWindowSetAutoHideCursor', (id, autoHide) => {
-        getWindowById(id).setAutoHideCursor(autoHide);
+        getWindowById(id)?.setAutoHideCursor(autoHide);
     });
 
     socket.on('browserWindowSetVibrancy', (id, type) => {
-        getWindowById(id).setVibrancy(type);
+        getWindowById(id)?.setVibrancy(type);
     });
 
     socket.on('browserWindow-setBrowserView', (id, browserViewId) => {
-        getWindowById(id).setBrowserView(browserViewMediateService(browserViewId));
+        getWindowById(id)?.setBrowserView(browserViewMediateService(browserViewId));
     });
 
     function getWindowById(id: number): Electron.BrowserWindow {
@@ -781,5 +785,6 @@ export = (socket: Socket, app: Electron.App) => {
                 return element;
             }
         }
+        return null;
     }
 };

ElectronNET.Host/api/dialog.js

@@ -7,12 +7,12 @@ module.exports = (socket) => {
         if ('id' in browserWindow) {
             const window = electron_1.BrowserWindow.fromId(browserWindow.id);
             const messageBoxReturnValue = await electron_1.dialog.showMessageBox(window, options);
-            electronSocket.emit('showMessageBoxComplete' + guid, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
+            electronSocket.emit('showMessageBoxComplete' + guid, { response: messageBoxReturnValue.response, checked: messageBoxReturnValue.checkboxChecked });
         }
         else {
             const id = guid || options;
             const messageBoxReturnValue = await electron_1.dialog.showMessageBox(browserWindow);
-            electronSocket.emit('showMessageBoxComplete' + id, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
+            electronSocket.emit('showMessageBoxComplete' + id, { response: messageBoxReturnValue.response, checked: messageBoxReturnValue.checkboxChecked });
         }
     });
     socket.on('showOpenDialog', async (browserWindow, options, guid) => {

ElectronNET.Host/api/dialog.ts

@@ -9,12 +9,12 @@ export = (socket: Socket) => {
             const window = BrowserWindow.fromId(browserWindow.id);
 
             const messageBoxReturnValue = await dialog.showMessageBox(window, options);
-            electronSocket.emit('showMessageBoxComplete' + guid, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
+            electronSocket.emit('showMessageBoxComplete' + guid, { response: messageBoxReturnValue.response, checked: messageBoxReturnValue.checkboxChecked });
         } else {
             const id = guid || options;
             const messageBoxReturnValue = await dialog.showMessageBox(browserWindow);
 
-            electronSocket.emit('showMessageBoxComplete' + id, [messageBoxReturnValue.response, messageBoxReturnValue.checkboxChecked]);
+            electronSocket.emit('showMessageBoxComplete' + id, { response: messageBoxReturnValue.response, checked: messageBoxReturnValue.checkboxChecked });
         }
     });
 

ElectronNET.Host/api/menu.js

@@ -7,7 +7,7 @@ module.exports = (socket) => {
     socket.on('menu-setContextMenu', (browserWindowId, menuItems) => {
         const menu = electron_1.Menu.buildFromTemplate(menuItems);
         addContextMenuItemClickConnector(menu.items, browserWindowId, (id, windowId) => {
-            electronSocket.emit('contextMenuItemClicked', [id, windowId]);
+            electronSocket.emit('contextMenuItemClicked', { id: id, windowId: windowId });
         });
         const index = contextMenuItems.findIndex(contextMenu => contextMenu.browserWindowId === browserWindowId);
         const contextMenuItem = {

ElectronNET.Host/api/menu.ts

@@ -9,7 +9,7 @@ export = (socket: Socket) => {
         const menu = Menu.buildFromTemplate(menuItems);
 
         addContextMenuItemClickConnector(menu.items, browserWindowId, (id, windowId) => {
-            electronSocket.emit('contextMenuItemClicked', [id, windowId]);
+            electronSocket.emit('contextMenuItemClicked', { id: id, windowId: windowId });
         });
 
         const index = contextMenuItems.findIndex(contextMenu => contextMenu.browserWindowId === browserWindowId);

ElectronNET.Host/api/screen.js

@@ -15,7 +15,7 @@ module.exports = (socket) => {
     });
     socket.on('register-screen-display-metrics-changed', (id) => {
         electron_1.screen.on('display-metrics-changed', (event, display, changedMetrics) => {
-            electronSocket.emit('screen-display-metrics-changed-event' + id, [display, changedMetrics]);
+            electronSocket.emit('screen-display-metrics-changed-event' + id, {display: display, changedMetrics: changedMetrics});
         });
     });
     socket.on('screen-getCursorScreenPoint', () => {

ElectronNET.Host/api/screen.ts

@@ -18,7 +18,7 @@ export = (socket: Socket) => {
 
     socket.on('register-screen-display-metrics-changed', (id) => {
         screen.on('display-metrics-changed', (event, display, changedMetrics) => {
-            electronSocket.emit('screen-display-metrics-changed-event' + id, [display, changedMetrics]);
+            electronSocket.emit('screen-display-metrics-changed-event' + id, { display: display, changedMetrics: changedMetrics });
         });
     });
 

ElectronNET.Host/api/tray.js

@@ -7,21 +7,21 @@ module.exports = (socket) => {
     socket.on('register-tray-click', (id) => {
         if (tray.value) {
             tray.value.on('click', (event, bounds) => {
-                electronSocket.emit('tray-click-event' + id, [event.__proto__, bounds]);
+                electronSocket.emit('tray-click-event' + id, { eventArgs: event.__proto__, bounds: bounds });
             });
         }
     });
     socket.on('register-tray-right-click', (id) => {
         if (tray.value) {
             tray.value.on('right-click', (event, bounds) => {
-                electronSocket.emit('tray-right-click-event' + id, [event.__proto__, bounds]);
+                electronSocket.emit('tray-right-click-event' + id, { eventArgs: event.__proto__, bounds: bounds });
             });
         }
     });
     socket.on('register-tray-double-click', (id) => {
         if (tray.value) {
             tray.value.on('double-click', (event, bounds) => {
-                electronSocket.emit('tray-double-click-event' + id, [event.__proto__, bounds]);
+                electronSocket.emit('tray-double-click-event' + id, { eventArgs: event.__proto__, bounds: bounds });
             });
         }
     });

ElectronNET.Host/api/tray.ts

@@ -8,7 +8,7 @@ export = (socket: Socket) => {
     socket.on('register-tray-click', (id) => {
         if (tray.value) {
             tray.value.on('click', (event, bounds) => {
-                electronSocket.emit('tray-click-event' + id, [(<any>event).__proto__, bounds]);
+                electronSocket.emit('tray-click-event' + id, {eventArgs: (<any>event).__proto__, bounds: bounds });
             });
         }
     });
@@ -16,7 +16,7 @@ export = (socket: Socket) => {
     socket.on('register-tray-right-click', (id) => {
         if (tray.value) {
             tray.value.on('right-click', (event, bounds) => {
-                electronSocket.emit('tray-right-click-event' + id, [(<any>event).__proto__, bounds]);
+                electronSocket.emit('tray-right-click-event' + id, { eventArgs: (<any>event).__proto__, bounds: bounds });
             });
         }
     });
@@ -24,7 +24,7 @@ export = (socket: Socket) => {
     socket.on('register-tray-double-click', (id) => {
         if (tray.value) {
             tray.value.on('double-click', (event, bounds) => {
-                electronSocket.emit('tray-double-click-event' + id, [(<any>event).__proto__, bounds]);
+                electronSocket.emit('tray-double-click-event' + id, { eventArgs: (<any>event).__proto__, bounds: bounds });
             });
         }
     });

ElectronNET.Host/api/webContents.js

@@ -29,20 +29,20 @@ module.exports = (socket) => {
     });
     socket.on('webContents-getPrinters', async (id) => {
         const printers = await getWindowById(id).webContents.getPrinters();
-        electronSocket.emit('webContents-getPrinters-completed', printers);
+        electronSocket.emit('webContents-getPrinters-completed' + Id, printers);
     });
     socket.on('webContents-print', async (id, options = {}) => {
         await getWindowById(id).webContents.print(options);
-        electronSocket.emit('webContents-print-completed', true);
+        electronSocket.emit('webContents-print-completed' + Id, true);
     });
     socket.on('webContents-printToPDF', async (id, options = {}, path) => {
         const buffer = await getWindowById(id).webContents.printToPDF(options);
         fs.writeFile(path, buffer, (error) => {
             if (error) {
-                electronSocket.emit('webContents-printToPDF-completed', false);
+                electronSocket.emit('webContents-printToPDF-completed' + Id, false);
             }
             else {
-                electronSocket.emit('webContents-printToPDF-completed', true);
+                electronSocket.emit('webContents-printToPDF-completed' + Id, true);
             }
         });
     });
@@ -141,7 +141,7 @@ module.exports = (socket) => {
         const browserWindow = getWindowById(id);
         browserWindow.webContents.session.cookies.removeAllListeners('changed');
         browserWindow.webContents.session.cookies.on('changed', (event, cookie, cause, removed) => {
-            electronSocket.emit('webContents-session-cookies-changed' + id, [cookie, cause, removed]);
+            electronSocket.emit('webContents-session-cookies-changed' + id, { cookie: cookie, cause: cause, removed: removed });
         });
     });
     socket.on('webContents-session-cookies-get', async (id, filter, guid) => {
@@ -201,7 +201,7 @@ module.exports = (socket) => {
         Object.keys(extensionsList).forEach(key => {
             chromeExtensionInfo.push(extensionsList[key]);
         });
-        electronSocket.emit('webContents-session-getAllExtensions-completed', chromeExtensionInfo);
+        electronSocket.emit('webContents-session-getAllExtensions-completed' + Id, chromeExtensionInfo);
     });
     socket.on('webContents-session-removeExtension', (id, name) => {
         const browserWindow = getWindowById(id);
@@ -210,7 +210,7 @@ module.exports = (socket) => {
     socket.on('webContents-session-loadExtension', async (id, path, allowFileAccess = false) => {
         const browserWindow = getWindowById(id);
         const extension = await browserWindow.webContents.session.loadExtension(path, { allowFileAccess: allowFileAccess });
-        electronSocket.emit('webContents-session-loadExtension-completed', extension);
+        electronSocket.emit('webContents-session-loadExtension-completed' + Id, extension);
     });
     function getWindowById(id) {
         if (id >= 1000) {

ElectronNET.Host/api/webContents.ts

@@ -34,12 +34,12 @@ export = (socket: Socket) => {
 
     socket.on('webContents-getPrinters', async (id) => {
         const printers = await getWindowById(id).webContents.getPrinters();
-        electronSocket.emit('webContents-getPrinters-completed', printers);
+        electronSocket.emit('webContents-getPrinters-completed' + Id, printers);
     });
 
     socket.on('webContents-print', async (id, options = {}) => {
         await getWindowById(id).webContents.print(options);
-        electronSocket.emit('webContents-print-completed', true);
+        electronSocket.emit('webContents-print-completed' + Id, true);
     });
 
     socket.on('webContents-printToPDF', async (id, options = {}, path) => {
@@ -47,9 +47,9 @@ export = (socket: Socket) => {
 
         fs.writeFile(path, buffer, (error) => {
             if (error) {
-                electronSocket.emit('webContents-printToPDF-completed', false);
+                electronSocket.emit('webContents-printToPDF-completed' + Id, false);
             } else {
-                electronSocket.emit('webContents-printToPDF-completed', true);
+                electronSocket.emit('webContents-printToPDF-completed' + Id, true);
             }
         });
     });
@@ -181,7 +181,7 @@ export = (socket: Socket) => {
 
         browserWindow.webContents.session.cookies.removeAllListeners('changed');
         browserWindow.webContents.session.cookies.on('changed', (event, cookie, cause, removed) => {
-            electronSocket.emit('webContents-session-cookies-changed' + id, [cookie, cause, removed]);
+            electronSocket.emit('webContents-session-cookies-changed' + id, { cookie: cookie, cause: cause, removed: removed });
         });
     });
 
@@ -253,7 +253,7 @@ export = (socket: Socket) => {
             chromeExtensionInfo.push(extensionsList[key]);
         });
 
-        electronSocket.emit('webContents-session-getAllExtensions-completed', chromeExtensionInfo);
+        electronSocket.emit('webContents-session-getAllExtensions-completed' + Id, chromeExtensionInfo);
     });
 
     socket.on('webContents-session-removeExtension', (id, name) => {
@@ -265,7 +265,7 @@ export = (socket: Socket) => {
         const browserWindow = getWindowById(id);
         const extension = await browserWindow.webContents.session.loadExtension(path, { allowFileAccess: allowFileAccess });
 
-        electronSocket.emit('webContents-session-loadExtension-completed', extension);
+        electronSocket.emit('webContents-session-loadExtension-completed' + Id, extension);
     });
 
     function getWindowById(id: number): Electron.BrowserWindow | Electron.BrowserView {

ElectronNET.Host/main.js

@@ -5,6 +5,7 @@ const path = require('path');
 const cProcess = require('child_process').spawn;
 const portscanner = require('portscanner');
 const { imageSize } = require('image-size');
+
 let io, server, browserWindows, ipc, apiProcess, loadURL;
 let appApi, menu, dialogApi, notification, tray, webContents;
 let globalShortcut, shellApi, screen, clipboard, autoUpdater;
@@ -101,7 +102,16 @@ app.on('ready', () => {
 
 app.on('quit', async (event, exitCode) => {
     await server.close();
-    apiProcess.kill();
+
+    var detachedProcess = false;
+
+    if (manifestJsonFile.hasOwnProperty('detachedProcess')) {
+        detachedProcess = manifestJsonFile.detachedProcess;
+    }
+
+    if (!detachedProcess) {
+        apiProcess.kill();
+    }
 });
 
 function isSplashScreenEnabled() {
@@ -118,7 +128,7 @@ function startSplashScreen() {
     let imageFile = path.join(currentBinPath, manifestJsonFile.splashscreen.imageFile);
     imageSize(imageFile, (error, dimensions) => {
         if (error) {
-            console.log(`load splashscreen error:`);
+            console.log('load splashscreen error:');
             console.error(error);
 
             throw new Error(error.message);
@@ -136,13 +146,28 @@ function startSplashScreen() {
             alwaysOnTop: true,
             show: true
         });
+
+        if (manifestJsonFile.hasOwnProperty('splashscreen')) {
+            if (manifestJsonFile.splashscreen.hasOwnProperty('timeout')) {
+                var timeout = manifestJsonFile.splashscreen.timeout;
+                setTimeout((t) => {
+                    if (splashScreen) {
+                        splashScreen.hide();
+                    }
+                }, timeout);
+            }
+        }
+
+
         splashScreen.setIgnoreMouseEvents(true);
 
         app.once('browser-window-created', () => {
             splashScreen.destroy();
+            splashScreen = null;
         });
 
         const loadSplashscreenUrl = path.join(__dirname, 'splashscreen', 'index.html') + '?imgPath=' + imageFile;
+
         splashScreen.loadURL('file://' + loadSplashscreenUrl);
 
         splashScreen.once('closed', () => {
@@ -246,6 +271,14 @@ function startSocketApiBridge(port) {
             }
         });
 
+        socket.on('console-stdout', (data) => {
+            console.log(`stdout: ${data.toString()}`);
+        });
+
+        socket.on('console-stderr', (data) => {
+            console.log(`stderr: ${data.toString()}`);
+        });
+
         try {
             const hostHookScriptFilePath = path.join(__dirname, 'ElectronHostHook', 'index.js');
 
@@ -281,7 +314,7 @@ function startAspCoreBackend(electronPort) {
     function startBackend(aspCoreBackendPort) {
         console.log('ASP.NET Core Port: ' + aspCoreBackendPort);
         loadURL = `http://localhost:${aspCoreBackendPort}`;
-        const parameters = [getEnvironmentParameter(), `/electronPort=${electronPort}`, `/electronWebPort=${aspCoreBackendPort}`];
+        const parameters = [getEnvironmentParameter(), `/electronPort=${electronPort}`, `/electronWebPort=${aspCoreBackendPort}`, `/electronPID=${process.pid}`];
         let binaryFile = manifestJsonFile.executable;
 
         const os = require('os');
@@ -289,13 +322,45 @@ function startAspCoreBackend(electronPort) {
             binaryFile = binaryFile + '.exe';
         }
 
+        var detachedProcess = false;
+        var stdioopt = 'pipe';
+
+        if (manifestJsonFile.hasOwnProperty('detachedProcess')) {
+            detachedProcess = manifestJsonFile.detachedProcess;
+            if (detachedProcess) {
+                stdioopt = 'ignore';
+            }
+        }
+
         let binFilePath = path.join(currentBinPath, binaryFile);
-        var options = { cwd: currentBinPath };
+
+        var options = { cwd: currentBinPath, detached: detachedProcess, stdio: stdioopt  };
+
         apiProcess = cProcess(binFilePath, parameters, options);
 
-        apiProcess.stdout.on('data', (data) => {
-            console.log(`stdout: ${data.toString()}`);
+        if (!detachedProcess) {
+            apiProcess.stdout.on('data', (data) => {
+                console.log(`stdout: ${data.toString()}`);
+            });
+
+            apiProcess.stderr.on('data', (data) => {
+                console.log(`stderr: ${data.toString()}`);
+            });
+        }
+
+        apiProcess.on('close', (code) => {
+            console.log(`ASP.NET Process exited with code ${code}`);
+            if (code != 0) {
+                console.log(`Will quit Electron, as exit code != 0 (got ${code})`);
+                app.exit(code);
+            }
         });
+
+        if (detachedProcess) {
+            console.log('Detached from ASP.NET process');
+            apiProcess.unref();
+        }
+
         apiProcess.stderr.on('data', (data) => {
             console.log(`stderr: ${data.toString()}`);
         });
@@ -315,17 +380,45 @@ function startAspCoreBackendWithWatch(electronPort) {
     function startBackend(aspCoreBackendPort) {
         console.log('ASP.NET Core Watch Port: ' + aspCoreBackendPort);
         loadURL = `http://localhost:${aspCoreBackendPort}`;
-        const parameters = ['watch', 'run', getEnvironmentParameter(), `/electronPort=${electronPort}`, `/electronWebPort=${aspCoreBackendPort}`];
+        const parameters = ['watch', 'run', getEnvironmentParameter(), `/electronPort=${electronPort}`, `/electronWebPort=${aspCoreBackendPort}`, `/electronPID=${process.pid}`];
+
+        var detachedProcess = false;
+        var stdioopt = 'pipe';
+
+        if (manifestJsonFile.hasOwnProperty('detachedProcess')) {
+            detachedProcess = manifestJsonFile.detachedProcess;
+            if (detachedProcess) {
+                stdioopt = 'ignore';
+            }
+        }
+
+        var options = { cwd: currentBinPath, env: process.env, detached: detachedProcess, stdio: stdioopt };
 
-        var options = {
-            cwd: currentBinPath,
-            env: process.env,
-        };
         apiProcess = cProcess('dotnet', parameters, options);
 
-        apiProcess.stdout.on('data', (data) => {
-            console.log(`stdout: ${data.toString()}`);
+        if (!detachedProcess) {
+            apiProcess.stdout.on('data', (data) => {
+                console.log(`stdout: ${data.toString()}`);
+            });
+
+            apiProcess.stderr.on('data', (data) => {
+                console.log(`stderr: ${data.toString()}`);
+            });
+        }
+
+        apiProcess.on('close', (code) => {
+            console.log(`ASP.NET Process exited with code ${code}`);
+            if (code != 0) {
+                console.log(`Will quit Electron, as exit code != 0 (got ${code})`);
+                app.exit(code);
+            }
         });
+
+        if (detachedProcess) {
+            console.log('Detached from ASP.NET process');
+            apiProcess.unref();
+        }
+      
         apiProcess.stderr.on('data', (data) => {
             console.log(`stderr: ${data.toString()}`);
         });

ElectronNET.WebApp/ElectronNET.WebApp.csproj

@@ -1,8 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
   <PropertyGroup>
     <TargetFramework>net5.0</TargetFramework>
-    <AspNetCoreHostingModel>OutOfProcess</AspNetCoreHostingModel>
-    <AspNetCoreModuleName>AspNetCoreModule</AspNetCoreModuleName>
     <RuntimeIdentifiers>win-x64</RuntimeIdentifiers>
     <TypeScriptToolsVersion>4.2</TypeScriptToolsVersion>
   </PropertyGroup>
@@ -17,6 +15,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="5.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\ElectronNET.API\ElectronNET.API.csproj" />

ElectronNET.WebApp/Program.cs

@@ -2,6 +2,7 @@
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Logging;
+using System.Diagnostics;
 
 namespace ElectronNET.WebApp
 {
@@ -9,6 +10,12 @@ namespace ElectronNET.WebApp
     {
         public static void Main(string[] args)
         {
+
+#if DEBUG
+            //Uncomment this line to automatically attach the Debugger on launch. This should only be used in development
+            //Debugger.Launch();
+#endif
+
             CreateWebHostBuilder(args).Build().Run();
         }
 

ElectronNET.WebApp/Properties/launchSettings.json

@@ -1,32 +1,10 @@
 {
-  "iisSettings": {
-    "windowsAuthentication": false,
-    "anonymousAuthentication": true,
-    "iisExpress": {
-      "applicationUrl": "http://localhost:50394/",
-      "sslPort": 0
-    }
-  },
   "profiles": {
     "Electron.NET App": {
       "commandName": "Executable",
-      "executablePath": "$(SolutionDir)ElectronNET.CLI\\bin\\Debug\\netcoreapp3.1\\dotnet-electronize.exe",
+      "executablePath": "$(SolutionDir)ElectronNET.CLI\\bin\\Debug\\net5.0\\dotnet-electronize.exe",
       "commandLineArgs": "start",
       "workingDirectory": "$(SolutionDir)ElectronNET.WebApp"
-    },
-    "IIS Express": {
-      "commandName": "IISExpress",
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      }
-    },
-    "ElectronNET.WebApp": {
-      "commandName": "Project",
-      "launchBrowser": true,
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      },
-      "applicationUrl": "http://localhost:50395/"
     }
   }
 }

ElectronNET.sln

@@ -1,9 +1,11 @@
-
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2027
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31112.23
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ElectronNET.WebApp", "ElectronNET.WebApp\ElectronNET.WebApp.csproj", "{7C048379-401C-4345-B5E7-BE232DEA8157}"
+	ProjectSection(ProjectDependencies) = postProject
+		{CE3EB0F2-DA39-427A-85D2-E00D660EBFDE} = {CE3EB0F2-DA39-427A-85D2-E00D660EBFDE}
+	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ElectronNET.API", "ElectronNET.API\ElectronNET.API.csproj", "{A78157BA-B754-45F1-969F-D6A513CA0E72}"
 EndProject
@@ -32,6 +34,7 @@ Project("{E24C65DC-7377-472B-9ABA-BC803B73C61A}") = "ElectronNET.Host", "Electro
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{2914CCF7-27C2-42AE-849A-2F0C1BC7CDFA}"
 	ProjectSection(SolutionItems) = preProject
+		.devops\build-nuget.yaml = .devops\build-nuget.yaml
 		buildAll.cmd = buildAll.cmd
 		buildAll.sh = buildAll.sh
 		buildReleaseNuGetPackages.cmd = buildReleaseNuGetPackages.cmd