diff --git a/ElectronNET.API/App.cs b/ElectronNET.API/App.cs
index 6baab53..a4ed890 100644
--- a/ElectronNET.API/App.cs
+++ b/ElectronNET.API/App.cs
@@ -30,7 +30,7 @@ namespace ElectronNET.API
             {
                 if (_windowAllClosed == null)
                 {
-                    BridgeConnector.Socket.On("app-window-all-closed" + GetHashCode(), () =>
+                    BridgeConnector.On("app-window-all-closed" + GetHashCode(), () =>
                     {
                         if (!Electron.WindowManager.IsQuitOnWindowAllClosed || RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
                         {
@@ -38,7 +38,7 @@ namespace ElectronNET.API
                         }
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-window-all-closed-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-window-all-closed-event", GetHashCode());
                 }
                 _windowAllClosed += value;
             }
@@ -47,7 +47,7 @@ namespace ElectronNET.API
                 _windowAllClosed -= value;
 
                 if(_windowAllClosed == null)
-                    BridgeConnector.Socket.Off("app-window-all-closed" + GetHashCode());
+                    BridgeConnector.Off("app-window-all-closed" + GetHashCode());
             }
         }
 
@@ -67,7 +67,7 @@ namespace ElectronNET.API
             {
                 if (_beforeQuit == null)
                 {
-                    BridgeConnector.Socket.On("app-before-quit" + GetHashCode(), async () =>
+                    BridgeConnector.On("app-before-quit" + GetHashCode(), async () =>
                     {
                         await _beforeQuit(new QuitEventArgs());
 
@@ -110,7 +110,7 @@ namespace ElectronNET.API
                         }
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-before-quit-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-before-quit-event", GetHashCode());
                 }
                 _beforeQuit += value;
             }
@@ -119,7 +119,7 @@ namespace ElectronNET.API
                 _beforeQuit -= value;
 
                 if (_beforeQuit == null)
-                    BridgeConnector.Socket.Off("app-before-quit" + GetHashCode());
+                    BridgeConnector.Off("app-before-quit" + GetHashCode());
             }
         }
 
@@ -139,7 +139,7 @@ namespace ElectronNET.API
             {
                 if (_willQuit == null)
                 {
-                    BridgeConnector.Socket.On("app-will-quit" + GetHashCode(), async () =>
+                    BridgeConnector.On("app-will-quit" + GetHashCode(), async () =>
                     {
                         await _willQuit(new QuitEventArgs());
 
@@ -161,7 +161,7 @@ namespace ElectronNET.API
                         }
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-will-quit-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-will-quit-event", GetHashCode());
                 }
                 _willQuit += value;
             }
@@ -170,7 +170,7 @@ namespace ElectronNET.API
                 _willQuit -= value;
 
                 if (_willQuit == null)
-                    BridgeConnector.Socket.Off("app-will-quit" + GetHashCode());
+                    BridgeConnector.Off("app-will-quit" + GetHashCode());
             }
         }
 
@@ -187,7 +187,7 @@ namespace ElectronNET.API
             {
                 if (_quitting == null)
                 {
-                    BridgeConnector.Socket.On("app-will-quit" + GetHashCode() + "quitting", async () =>
+                    BridgeConnector.On("app-will-quit" + GetHashCode() + "quitting", async () =>
                     {
                         if(_willQuit == null)
                         {
@@ -196,7 +196,7 @@ namespace ElectronNET.API
                         }
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-will-quit-event", GetHashCode() + "quitting");
+                    BridgeConnector.Emit("register-app-will-quit-event", GetHashCode() + "quitting");
                 }
                 _quitting += value;
             }
@@ -205,7 +205,7 @@ namespace ElectronNET.API
                 _quitting -= value;
 
                 if (_quitting == null)
-                    BridgeConnector.Socket.Off("app-will-quit" + GetHashCode() + "quitting");
+                    BridgeConnector.Off("app-will-quit" + GetHashCode() + "quitting");
             }
         }
 
@@ -220,12 +220,12 @@ namespace ElectronNET.API
             {
                 if (_browserWindowBlur == null)
                 {
-                    BridgeConnector.Socket.On("app-browser-window-blur" + GetHashCode(), () =>
+                    BridgeConnector.On("app-browser-window-blur" + GetHashCode(), () =>
                     {
                         _browserWindowBlur();
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-browser-window-blur-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-browser-window-blur-event", GetHashCode());
                 }
                 _browserWindowBlur += value;
             }
@@ -234,7 +234,7 @@ namespace ElectronNET.API
                 _browserWindowBlur -= value;
 
                 if (_browserWindowBlur == null)
-                    BridgeConnector.Socket.Off("app-browser-window-blur" + GetHashCode());
+                    BridgeConnector.Off("app-browser-window-blur" + GetHashCode());
             }
         }
 
@@ -249,12 +249,12 @@ namespace ElectronNET.API
             {
                 if (_browserWindowFocus == null)
                 {
-                    BridgeConnector.Socket.On("app-browser-window-focus" + GetHashCode(), () =>
+                    BridgeConnector.On("app-browser-window-focus" + GetHashCode(), () =>
                     {
                         _browserWindowFocus();
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-browser-window-focus-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-browser-window-focus-event", GetHashCode());
                 }
                 _browserWindowFocus += value;
             }
@@ -263,7 +263,7 @@ namespace ElectronNET.API
                 _browserWindowFocus -= value;
 
                 if (_browserWindowFocus == null)
-                    BridgeConnector.Socket.Off("app-browser-window-focus" + GetHashCode());
+                    BridgeConnector.Off("app-browser-window-focus" + GetHashCode());
             }
         }
 
@@ -278,12 +278,12 @@ namespace ElectronNET.API
             {
                 if (_browserWindowCreated == null)
                 {
-                    BridgeConnector.Socket.On("app-browser-window-created" + GetHashCode(), () =>
+                    BridgeConnector.On("app-browser-window-created" + GetHashCode(), () =>
                     {
                         _browserWindowCreated();
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-browser-window-created-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-browser-window-created-event", GetHashCode());
                 }
                 _browserWindowCreated += value;
             }
@@ -292,7 +292,7 @@ namespace ElectronNET.API
                 _browserWindowCreated -= value;
 
                 if (_browserWindowCreated == null)
-                    BridgeConnector.Socket.Off("app-browser-window-created" + GetHashCode());
+                    BridgeConnector.Off("app-browser-window-created" + GetHashCode());
             }
         }
 
@@ -307,12 +307,12 @@ namespace ElectronNET.API
             {
                 if (_webContentsCreated == null)
                 {
-                    BridgeConnector.Socket.On("app-web-contents-created" + GetHashCode(), () =>
+                    BridgeConnector.On("app-web-contents-created" + GetHashCode(), () =>
                     {
                         _webContentsCreated();
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-web-contents-created-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-web-contents-created-event", GetHashCode());
                 }
                 _webContentsCreated += value;
             }
@@ -321,7 +321,7 @@ namespace ElectronNET.API
                 _webContentsCreated -= value;
 
                 if (_webContentsCreated == null)
-                    BridgeConnector.Socket.Off("app-web-contents-created" + GetHashCode());
+                    BridgeConnector.Off("app-web-contents-created" + GetHashCode());
             }
         }
 
@@ -338,12 +338,12 @@ namespace ElectronNET.API
             {
                 if (_accessibilitySupportChanged == null)
                 {
-                    BridgeConnector.Socket.On("app-accessibility-support-changed" + GetHashCode(), (state) =>
+                    BridgeConnector.On("app-accessibility-support-changed" + GetHashCode(), (state) =>
                     {
                         _accessibilitySupportChanged((bool)state);
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-accessibility-support-changed-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-accessibility-support-changed-event", GetHashCode());
                 }
                 _accessibilitySupportChanged += value;
             }
@@ -352,7 +352,7 @@ namespace ElectronNET.API
                 _accessibilitySupportChanged -= value;
 
                 if (_accessibilitySupportChanged == null)
-                    BridgeConnector.Socket.Off("app-accessibility-support-changed" + GetHashCode());
+                    BridgeConnector.Off("app-accessibility-support-changed" + GetHashCode());
             }
         }
 
@@ -412,12 +412,12 @@ namespace ElectronNET.API
             {
                 if (_openFile == null)
                 {
-                    BridgeConnector.Socket.On("app-open-file" + GetHashCode(), (file) =>
+                    BridgeConnector.On<string>("app-open-file" + GetHashCode(), (file) =>
                     {
-                        _openFile(file.ToString());
+                        _openFile(file);
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-open-file-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-open-file-event", GetHashCode());
                 }
                 _openFile += value;
             }
@@ -426,7 +426,7 @@ namespace ElectronNET.API
                 _openFile -= value;
 
                 if (_openFile == null)
-                    BridgeConnector.Socket.Off("app-open-file" + GetHashCode());
+                    BridgeConnector.Off("app-open-file" + GetHashCode());
             }
         }
 
@@ -443,12 +443,12 @@ namespace ElectronNET.API
             {
                 if (_openUrl == null)
                 {
-                    BridgeConnector.Socket.On("app-open-url" + GetHashCode(), (url) =>
+                    BridgeConnector.On<string>("app-open-url" + GetHashCode(), (url) =>
                     {
-                        _openUrl(url.ToString());
+                        _openUrl(url);
                     });
 
-                    BridgeConnector.Socket.Emit("register-app-open-url-event", GetHashCode());
+                    BridgeConnector.Emit("register-app-open-url-event", GetHashCode());
                 }
                 _openUrl += value;
             }
@@ -457,7 +457,7 @@ namespace ElectronNET.API
                 _openUrl -= value;
 
                 if (_openUrl == null)
-                    BridgeConnector.Socket.Off("app-open-url" + GetHashCode());
+                    BridgeConnector.Off("app-open-url" + GetHashCode());
             }
         }
 
@@ -475,7 +475,7 @@ namespace ElectronNET.API
         {
             set
             {
-                BridgeConnector.Socket.Emit("appSetName", value);
+                BridgeConnector.Emit("appSetName", value);
             }
         }
 
@@ -491,13 +491,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("appGetNameCompleted", (result) =>
+            BridgeConnector.On<string>("appGetNameCompleted", (result) =>
             {
-                BridgeConnector.Socket.Off("appGetNameCompleted");
-                taskCompletionSource.SetResult((string)result);
+                BridgeConnector.Off("appGetNameCompleted");
+                taskCompletionSource.SetResult(result);
             });
 
-            BridgeConnector.Socket.Emit("appGetName");
+            BridgeConnector.Emit("appGetName");
 
             return taskCompletionSource.Task;
         }
@@ -551,7 +551,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Quit()
         {
-            BridgeConnector.Socket.Emit("appQuit");
+            BridgeConnector.Emit("appQuit");
         }
 
         /// <summary>
@@ -561,7 +561,7 @@ namespace ElectronNET.API
         /// <param name="exitCode">Exits immediately with exitCode. exitCode defaults to 0.</param>
         public void Exit(int exitCode = 0)
         {
-            BridgeConnector.Socket.Emit("appExit", exitCode);
+            BridgeConnector.Emit("appExit", exitCode);
         }
 
         /// <summary>
@@ -576,7 +576,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Relaunch()
         {
-            BridgeConnector.Socket.Emit("appRelaunch");
+            BridgeConnector.Emit("appRelaunch");
         }
 
         /// <summary>
@@ -594,7 +594,7 @@ namespace ElectronNET.API
         /// <param name="relaunchOptions">Options for the relaunch.</param>
         public void Relaunch(RelaunchOptions relaunchOptions)
         {
-            BridgeConnector.Socket.Emit("appRelaunch", JObject.FromObject(relaunchOptions, _jsonSerializer));
+            BridgeConnector.Emit("appRelaunch", JObject.FromObject(relaunchOptions, _jsonSerializer));
         }
 
         /// <summary>
@@ -603,7 +603,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Focus()
         {
-            BridgeConnector.Socket.Emit("appFocus");
+            BridgeConnector.Emit("appFocus");
         }
 
         /// <summary>
@@ -614,7 +614,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Focus(FocusOptions focusOptions)
         {
-            BridgeConnector.Socket.Emit("appFocus", JObject.FromObject(focusOptions, _jsonSerializer));
+            BridgeConnector.Emit("appFocus", JObject.FromObject(focusOptions, _jsonSerializer));
         }
 
         /// <summary>
@@ -622,7 +622,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Hide()
         {
-            BridgeConnector.Socket.Emit("appHide");
+            BridgeConnector.Emit("appHide");
         }
 
         /// <summary>
@@ -630,7 +630,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Show()
         {
-            BridgeConnector.Socket.Emit("appShow");
+            BridgeConnector.Emit("appShow");
         }
 
         /// <summary>
@@ -643,13 +643,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             using(cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetAppPathCompleted", (path) =>
+                BridgeConnector.On<string>("appGetAppPathCompleted", (path) =>
                 {
-                    BridgeConnector.Socket.Off("appGetAppPathCompleted");
-                    taskCompletionSource.SetResult(path.ToString());
+                    BridgeConnector.Off("appGetAppPathCompleted");
+                    taskCompletionSource.SetResult(path);
                 });
 
-                BridgeConnector.Socket.Emit("appGetAppPath");
+                BridgeConnector.Emit("appGetAppPath");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -666,7 +666,7 @@ namespace ElectronNET.API
         /// <param name="path">A custom path for your logs. Must be absolute.</param>
         public void SetAppLogsPath(string path)
         {
-            BridgeConnector.Socket.Emit("appSetAppLogsPath", path);
+            BridgeConnector.Emit("appSetAppLogsPath", path);
         }
 
         /// <summary>
@@ -684,14 +684,14 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             using(cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetPathCompleted", (path) =>
+                BridgeConnector.On<string>("appGetPathCompleted", (path) =>
                 {
-                    BridgeConnector.Socket.Off("appGetPathCompleted");
+                    BridgeConnector.Off("appGetPathCompleted");
 
-                    taskCompletionSource.SetResult(path.ToString());
+                    taskCompletionSource.SetResult(path);
                 });
 
-                BridgeConnector.Socket.Emit("appGetPath", pathName.GetDescription());
+                BridgeConnector.Emit("appGetPath", pathName.GetDescription());
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -712,7 +712,7 @@ namespace ElectronNET.API
         /// </summary>
         public void SetPath(PathName name, string path)
         {
-            BridgeConnector.Socket.Emit("appSetPath", name.GetDescription(), path);
+            BridgeConnector.Emit("appSetPath", name.GetDescription(), path);
         }
 
         /// <summary>
@@ -727,13 +727,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             using(cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetVersionCompleted", (version) =>
+                BridgeConnector.On<string>("appGetVersionCompleted", (version) =>
                 {
-                    BridgeConnector.Socket.Off("appGetVersionCompleted");
-                    taskCompletionSource.SetResult(version.ToString());
+                    BridgeConnector.Off("appGetVersionCompleted");
+                    taskCompletionSource.SetResult(version);
                 });
 
-                BridgeConnector.Socket.Emit("appGetVersion");
+                BridgeConnector.Emit("appGetVersion");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -755,13 +755,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetLocaleCompleted", (local) =>
+                BridgeConnector.On<string>("appGetLocaleCompleted", (local) =>
                 {
-                    BridgeConnector.Socket.Off("appGetLocaleCompleted");
-                    taskCompletionSource.SetResult(local.ToString());
+                    BridgeConnector.Off("appGetLocaleCompleted");
+                    taskCompletionSource.SetResult(local);
                 });
 
-                BridgeConnector.Socket.Emit("appGetLocale");
+                BridgeConnector.Emit("appGetLocale");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -775,7 +775,7 @@ namespace ElectronNET.API
         /// <param name="path">Path to add.</param>
         public void AddRecentDocument(string path)
         {
-            BridgeConnector.Socket.Emit("appAddRecentDocument", path);
+            BridgeConnector.Emit("appAddRecentDocument", path);
         }
 
         /// <summary>
@@ -783,7 +783,7 @@ namespace ElectronNET.API
         /// </summary>
         public void ClearRecentDocuments()
         {
-            BridgeConnector.Socket.Emit("appClearRecentDocuments");
+            BridgeConnector.Emit("appClearRecentDocuments");
         }
 
         /// <summary>
@@ -881,13 +881,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appSetAsDefaultProtocolClientCompleted", (success) =>
+                BridgeConnector.On<bool>("appSetAsDefaultProtocolClientCompleted", (success) =>
                 {
-                    BridgeConnector.Socket.Off("appSetAsDefaultProtocolClientCompleted");
-                    taskCompletionSource.SetResult((bool) success);
+                    BridgeConnector.Off("appSetAsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult(success);
                 });
 
-                BridgeConnector.Socket.Emit("appSetAsDefaultProtocolClient", protocol, path, args);
+                BridgeConnector.Emit("appSetAsDefaultProtocolClient", protocol, path, args);
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -935,13 +935,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appRemoveAsDefaultProtocolClientCompleted", (success) =>
+                BridgeConnector.On<bool>("appRemoveAsDefaultProtocolClientCompleted", (success) =>
                 {
-                    BridgeConnector.Socket.Off("appRemoveAsDefaultProtocolClientCompleted");
-                    taskCompletionSource.SetResult((bool) success);
+                    BridgeConnector.Off("appRemoveAsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult(success);
                 });
 
-                BridgeConnector.Socket.Emit("appRemoveAsDefaultProtocolClient", protocol, path, args);
+                BridgeConnector.Emit("appRemoveAsDefaultProtocolClient", protocol, path, args);
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1007,13 +1007,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appIsDefaultProtocolClientCompleted", (success) =>
+                BridgeConnector.On<bool>("appIsDefaultProtocolClientCompleted", (success) =>
                 {
-                    BridgeConnector.Socket.Off("appIsDefaultProtocolClientCompleted");
-                    taskCompletionSource.SetResult((bool) success);
+                    BridgeConnector.Off("appIsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult(success);
                 });
 
-                BridgeConnector.Socket.Emit("appIsDefaultProtocolClient", protocol, path, args);
+                BridgeConnector.Emit("appIsDefaultProtocolClient", protocol, path, args);
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1035,13 +1035,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appSetUserTasksCompleted", (success) =>
+                BridgeConnector.On<bool>("appSetUserTasksCompleted", (success) =>
                 {
-                    BridgeConnector.Socket.Off("appSetUserTasksCompleted");
-                    taskCompletionSource.SetResult((bool) success);
+                    BridgeConnector.Off("appSetUserTasksCompleted");
+                    taskCompletionSource.SetResult(success);
                 });
 
-                BridgeConnector.Socket.Emit("appSetUserTasks", JArray.FromObject(userTasks, _jsonSerializer));
+                BridgeConnector.Emit("appSetUserTasks", JArray.FromObject(userTasks, _jsonSerializer));
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1060,13 +1060,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<JumpListSettings>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetJumpListSettingsCompleted", (jumpListSettings) =>
+                BridgeConnector.On<JumpListSettings>("appGetJumpListSettingsCompleted", (jumpListSettings) =>
                 {
-                    BridgeConnector.Socket.Off("appGetJumpListSettingsCompleted");
-                    taskCompletionSource.SetResult(JObject.Parse(jumpListSettings.ToString()).ToObject<JumpListSettings>());
+                    BridgeConnector.Off("appGetJumpListSettingsCompleted");
+                    taskCompletionSource.SetResult(jumpListSettings);
                 });
 
-                BridgeConnector.Socket.Emit("appGetJumpListSettings");
+                BridgeConnector.Emit("appGetJumpListSettings");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1091,7 +1091,7 @@ namespace ElectronNET.API
         /// <param name="categories">Array of <see cref="JumpListCategory"/> objects.</param>
         public void SetJumpList(JumpListCategory[] categories)
         {
-            BridgeConnector.Socket.Emit("appSetJumpList", JArray.FromObject(categories, _jsonSerializer));
+            BridgeConnector.Emit("appSetJumpList", JArray.FromObject(categories, _jsonSerializer));
         }
 
         /// <summary>
@@ -1122,23 +1122,19 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appRequestSingleInstanceLockCompleted", (success) =>
+                BridgeConnector.On<bool>("appRequestSingleInstanceLockCompleted", (success) =>
                 {
-                    BridgeConnector.Socket.Off("appRequestSingleInstanceLockCompleted");
-                    taskCompletionSource.SetResult((bool)success);
+                    BridgeConnector.Off("appRequestSingleInstanceLockCompleted");
+                    taskCompletionSource.SetResult(success);
                 });
 
-                BridgeConnector.Socket.Off("secondInstance");
-                BridgeConnector.Socket.On("secondInstance", (result) =>
+                BridgeConnector.Off("secondInstance");
+                BridgeConnector.On<SecondInstanceResponse>("secondInstance", (result) =>
                 {
-                    JArray results = (JArray)result;
-                    string[] args = results.First.ToObject<string[]>();
-                    string workingDirectory = results.Last.ToObject<string>();
-
-                    newInstanceOpened(args, workingDirectory);
+                    newInstanceOpened(result.args, result.workingDirectory);
                 });
 
-                BridgeConnector.Socket.Emit("appRequestSingleInstanceLock");
+                BridgeConnector.Emit("appRequestSingleInstanceLock");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1151,7 +1147,7 @@ namespace ElectronNET.API
         /// </summary>
         public void ReleaseSingleInstanceLock()
         {
-            BridgeConnector.Socket.Emit("appReleaseSingleInstanceLock");
+            BridgeConnector.Emit("appReleaseSingleInstanceLock");
         }
 
         /// <summary>
@@ -1167,16 +1163,15 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appHasSingleInstanceLockCompleted", (hasLock) =>
+                BridgeConnector.On<bool>("appHasSingleInstanceLockCompleted", (hasLock) =>
                 {
-                    BridgeConnector.Socket.Off("appHasSingleInstanceLockCompleted");
-                    taskCompletionSource.SetResult((bool) hasLock);
+                    BridgeConnector.Off("appHasSingleInstanceLockCompleted");
+                    taskCompletionSource.SetResult(hasLock);
                 });
 
-                BridgeConnector.Socket.Emit("appHasSingleInstanceLock");
+                BridgeConnector.Emit("appHasSingleInstanceLock");
 
-                return await taskCompletionSource.Task
-                    .ConfigureAwait(false);
+                return await taskCompletionSource.Task.ConfigureAwait(false);
             }
         }
 
@@ -1206,7 +1201,7 @@ namespace ElectronNET.API
         /// </param>
         public void SetUserActivity(string type, object userInfo, string webpageUrl)
         {
-            BridgeConnector.Socket.Emit("appSetUserActivity", type, userInfo, webpageUrl);
+            BridgeConnector.Emit("appSetUserActivity", type, userInfo, webpageUrl);
         }
 
         /// <summary>
@@ -1220,16 +1215,15 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetCurrentActivityTypeCompleted", (activityType) =>
+                BridgeConnector.On<string>("appGetCurrentActivityTypeCompleted", (activityType) =>
                 {
-                    BridgeConnector.Socket.Off("appGetCurrentActivityTypeCompleted");
-                    taskCompletionSource.SetResult(activityType.ToString());
+                    BridgeConnector.Off("appGetCurrentActivityTypeCompleted");
+                    taskCompletionSource.SetResult(activityType);
                 });
 
-                BridgeConnector.Socket.Emit("appGetCurrentActivityType");
+                BridgeConnector.Emit("appGetCurrentActivityType");
 
-                return await taskCompletionSource.Task
-                    .ConfigureAwait(false);
+                return await taskCompletionSource.Task.ConfigureAwait(false);
             }
         }
 
@@ -1238,7 +1232,7 @@ namespace ElectronNET.API
         /// </summary>
         public void InvalidateCurrentActivity()
         {
-            BridgeConnector.Socket.Emit("appInvalidateCurrentActivity");
+            BridgeConnector.Emit("appInvalidateCurrentActivity");
         }
 
         /// <summary>
@@ -1246,7 +1240,7 @@ namespace ElectronNET.API
         /// </summary>
         public void ResignCurrentActivity()
         {
-            BridgeConnector.Socket.Emit("appResignCurrentActivity");
+            BridgeConnector.Emit("appResignCurrentActivity");
         }
 
         /// <summary>
@@ -1255,7 +1249,7 @@ namespace ElectronNET.API
         /// <param name="id">Model Id.</param>
         public void SetAppUserModelId(string id)
         {
-            BridgeConnector.Socket.Emit("appSetAppUserModelId", id);
+            BridgeConnector.Emit("appSetAppUserModelId", id);
         }
 
         /// TODO: Check new parameter which is a function [App.ImportCertificate]
@@ -1274,13 +1268,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<int>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appImportCertificateCompleted", (result) =>
+                BridgeConnector.On<int>("appImportCertificateCompleted", (result) =>
                 {
-                    BridgeConnector.Socket.Off("appImportCertificateCompleted");
-                    taskCompletionSource.SetResult((int) result);
+                    BridgeConnector.Off("appImportCertificateCompleted");
+                    taskCompletionSource.SetResult(result);
                 });
 
-                BridgeConnector.Socket.Emit("appImportCertificate", JObject.FromObject(options, _jsonSerializer));
+                BridgeConnector.Emit("appImportCertificate", JObject.FromObject(options, _jsonSerializer));
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1302,15 +1296,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<ProcessMetric[]>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetAppMetricsCompleted", (result) =>
+                BridgeConnector.On<ProcessMetric[]>("appGetAppMetricsCompleted", (result) =>
                 {
-                    BridgeConnector.Socket.Off("appGetAppMetricsCompleted");
-                    var processMetrics = ((JArray)result).ToObject<ProcessMetric[]>();
-
-                    taskCompletionSource.SetResult(processMetrics);
+                    BridgeConnector.Off("appGetAppMetricsCompleted");
+                    taskCompletionSource.SetResult(result);
                 });
 
-                BridgeConnector.Socket.Emit("appGetAppMetrics");
+                BridgeConnector.Emit("appGetAppMetrics");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1330,15 +1322,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<GPUFeatureStatus>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetGpuFeatureStatusCompleted", (result) =>
+                BridgeConnector.On<GPUFeatureStatus>("appGetGpuFeatureStatusCompleted", (result) =>
                 {
-                    BridgeConnector.Socket.Off("appGetGpuFeatureStatusCompleted");
-                    var gpuFeatureStatus = ((JObject)result).ToObject<GPUFeatureStatus>();
-
-                    taskCompletionSource.SetResult(gpuFeatureStatus);
+                    BridgeConnector.Off("appGetGpuFeatureStatusCompleted");
+                    taskCompletionSource.SetResult(result);
                 });
 
-                BridgeConnector.Socket.Emit("appGetGpuFeatureStatus");
+                BridgeConnector.Emit("appGetGpuFeatureStatus");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1362,13 +1352,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appSetBadgeCountCompleted", (success) =>
+                BridgeConnector.On<bool>("appSetBadgeCountCompleted", (success) =>
                 {
-                    BridgeConnector.Socket.Off("appSetBadgeCountCompleted");
-                    taskCompletionSource.SetResult((bool) success);
+                    BridgeConnector.Off("appSetBadgeCountCompleted");
+                    taskCompletionSource.SetResult(success);
                 });
 
-                BridgeConnector.Socket.Emit("appSetBadgeCount", count);
+                BridgeConnector.Emit("appSetBadgeCount", count);
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1386,13 +1376,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<int>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetBadgeCountCompleted", (count) =>
+                BridgeConnector.On<int>("appGetBadgeCountCompleted", (count) =>
                 {
-                    BridgeConnector.Socket.Off("appGetBadgeCountCompleted");
-                    taskCompletionSource.SetResult((int)count);
+                    BridgeConnector.Off("appGetBadgeCountCompleted");
+                    taskCompletionSource.SetResult(count);
                 });
 
-                BridgeConnector.Socket.Emit("appGetBadgeCount");
+                BridgeConnector.Emit("appGetBadgeCount");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1415,13 +1405,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appIsUnityRunningCompleted", (isUnityRunning) =>
+                BridgeConnector.On<bool>("appIsUnityRunningCompleted", (isUnityRunning) =>
                 {
-                    BridgeConnector.Socket.Off("appIsUnityRunningCompleted");
-                    taskCompletionSource.SetResult((bool)isUnityRunning);
+                    BridgeConnector.Off("appIsUnityRunningCompleted");
+                    taskCompletionSource.SetResult(isUnityRunning);
                 });
 
-                BridgeConnector.Socket.Emit("appIsUnityRunning");
+                BridgeConnector.Emit("appIsUnityRunning");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1450,22 +1440,19 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<LoginItemSettings>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appGetLoginItemSettingsCompleted", (loginItemSettings) =>
+                BridgeConnector.On<LoginItemSettings>("appGetLoginItemSettingsCompleted", (result) =>
                 {
-                    BridgeConnector.Socket.Off("appGetLoginItemSettingsCompleted");
-
-                    var result = ((JObject) loginItemSettings).ToObject<LoginItemSettings>();
-
+                    BridgeConnector.Off("appGetLoginItemSettingsCompleted");
                     taskCompletionSource.SetResult(result);
                 });
 
                 if (options == null)
                 {
-                    BridgeConnector.Socket.Emit("appGetLoginItemSettings");
+                    BridgeConnector.Emit("appGetLoginItemSettings");
                 }
                 else
                 {
-                    BridgeConnector.Socket.Emit("appGetLoginItemSettings", JObject.FromObject(options, _jsonSerializer));
+                    BridgeConnector.Emit("appGetLoginItemSettings", JObject.FromObject(options, _jsonSerializer));
                 }
 
                 return await taskCompletionSource.Task
@@ -1481,7 +1468,7 @@ namespace ElectronNET.API
         /// <param name="loginSettings"></param>
         public void SetLoginItemSettings(LoginSettings loginSettings)
         {
-            BridgeConnector.Socket.Emit("appSetLoginItemSettings", JObject.FromObject(loginSettings, _jsonSerializer));
+            BridgeConnector.Emit("appSetLoginItemSettings", JObject.FromObject(loginSettings, _jsonSerializer));
         }
 
         /// <summary>
@@ -1497,13 +1484,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appIsAccessibilitySupportEnabledCompleted", (isAccessibilitySupportEnabled) =>
+                BridgeConnector.On<bool>("appIsAccessibilitySupportEnabledCompleted", (isAccessibilitySupportEnabled) =>
                 {
-                    BridgeConnector.Socket.Off("appIsAccessibilitySupportEnabledCompleted");
-                    taskCompletionSource.SetResult((bool)isAccessibilitySupportEnabled);
+                    BridgeConnector.Off("appIsAccessibilitySupportEnabledCompleted");
+                    taskCompletionSource.SetResult(isAccessibilitySupportEnabled);
                 });
 
-                BridgeConnector.Socket.Emit("appIsAccessibilitySupportEnabled");
+                BridgeConnector.Emit("appIsAccessibilitySupportEnabled");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -1522,7 +1509,7 @@ namespace ElectronNET.API
         /// <param name="enabled">Enable or disable <see href="https://developers.google.com/web/fundamentals/accessibility/semantics-builtin/the-accessibility-tree">accessibility tree</see> rendering.</param>
         public void SetAccessibilitySupportEnabled(bool enabled)
         {
-            BridgeConnector.Socket.Emit("appSetAboutPanelOptions", enabled);
+            BridgeConnector.Emit("appSetAboutPanelOptions", enabled);
         }
 
         /// <summary>
@@ -1531,7 +1518,7 @@ namespace ElectronNET.API
         /// </summary>
         public void ShowAboutPanel()
         {
-            BridgeConnector.Socket.Emit("appShowAboutPanel");
+            BridgeConnector.Emit("appShowAboutPanel");
         }
 
         /// <summary>
@@ -1547,7 +1534,7 @@ namespace ElectronNET.API
         /// <param name="options">About panel options.</param>
         public void SetAboutPanelOptions(AboutPanelOptions options)
         {
-            BridgeConnector.Socket.Emit("appSetAboutPanelOptions", JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("appSetAboutPanelOptions", JObject.FromObject(options, _jsonSerializer));
         }
 
         /// <summary>
@@ -1562,7 +1549,7 @@ namespace ElectronNET.API
         {
             set
             {
-                BridgeConnector.Socket.Emit("appSetUserAgentFallback", value);
+                BridgeConnector.Emit("appSetUserAgentFallback", value);
             }
         }
 
@@ -1578,13 +1565,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("appGetUserAgentFallbackCompleted", (result) =>
+            BridgeConnector.On<string>("appGetUserAgentFallbackCompleted", (result) =>
             {
-                BridgeConnector.Socket.Off("appGetUserAgentFallbackCompleted");
-                taskCompletionSource.SetResult((string)result);
+                BridgeConnector.Off("appGetUserAgentFallbackCompleted");
+                taskCompletionSource.SetResult(result);
             });
 
-            BridgeConnector.Socket.Emit("appGetUserAgentFallback");
+            BridgeConnector.Emit("appGetUserAgentFallback");
 
             return taskCompletionSource.Task;
         }
@@ -1609,8 +1596,7 @@ namespace ElectronNET.API
         /// </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);
+        public void On(string eventName, Action<object> fn) => Events.Instance.On(ModuleName, eventName, fn);
         /// <summary>
         /// Subscribe to an unmapped event on the <see cref="App"/> module once.
         /// </summary>
diff --git a/ElectronNET.API/AutoUpdater.cs b/ElectronNET.API/AutoUpdater.cs
index 2d8f656..ae1c337 100644
--- a/ElectronNET.API/AutoUpdater.cs
+++ b/ElectronNET.API/AutoUpdater.cs
@@ -20,13 +20,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("autoUpdater-autoDownload-get-reply", (result) =>
+            BridgeConnector.On<bool>("autoUpdater-autoDownload-get-reply", (result) =>
             {
-                BridgeConnector.Socket.Off("autoUpdater-autoDownload-get-reply");
+                BridgeConnector.Off("autoUpdater-autoDownload-get-reply");
                 taskCompletionSource.SetResult((bool)result);
             });
 
-            BridgeConnector.Socket.Emit("autoUpdater-autoDownload-get");
+            BridgeConnector.Emit("autoUpdater-autoDownload-get");
 
             return taskCompletionSource.Task;
         }
@@ -40,13 +40,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("autoUpdater-autoInstallOnAppQuit-get-reply", (result) =>
+            BridgeConnector.On<bool>("autoUpdater-autoInstallOnAppQuit-get-reply", (result) =>
             {
-                BridgeConnector.Socket.Off("autoUpdater-autoInstallOnAppQuit-get-reply");
+                BridgeConnector.Off("autoUpdater-autoInstallOnAppQuit-get-reply");
                 taskCompletionSource.SetResult((bool)result);
             });
 
-            BridgeConnector.Socket.Emit("autoUpdater-autoInstallOnAppQuit-get");
+            BridgeConnector.Emit("autoUpdater-autoInstallOnAppQuit-get");
 
             return taskCompletionSource.Task;
         }
@@ -61,13 +61,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("autoUpdater-allowPrerelease-get-reply", (result) =>
+            BridgeConnector.On<bool>("autoUpdater-allowPrerelease-get-reply", (result) =>
             {
-                BridgeConnector.Socket.Off("autoUpdater-allowPrerelease-get-reply");
+                BridgeConnector.Off("autoUpdater-allowPrerelease-get-reply");
                 taskCompletionSource.SetResult((bool)result);
             });
 
-            BridgeConnector.Socket.Emit("autoUpdater-allowPrerelease-get");
+            BridgeConnector.Emit("autoUpdater-allowPrerelease-get");
 
             return taskCompletionSource.Task;
         }
@@ -80,13 +80,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("autoUpdater-fullChangelog-get-reply", (result) =>
+            BridgeConnector.On<bool>("autoUpdater-fullChangelog-get-reply", (result) =>
             {
-                BridgeConnector.Socket.Off("autoUpdater-fullChangelog-get-reply");
+                BridgeConnector.Off("autoUpdater-fullChangelog-get-reply");
                 taskCompletionSource.SetResult((bool)result);
             });
 
-            BridgeConnector.Socket.Emit("autoUpdater-fullChangelog-get");
+            BridgeConnector.Emit("autoUpdater-fullChangelog-get");
 
             return taskCompletionSource.Task;
         }
@@ -95,13 +95,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("autoUpdater-allowDowngrade-get-reply", (result) =>
+            BridgeConnector.On<bool>("autoUpdater-allowDowngrade-get-reply", (result) =>
             {
-                BridgeConnector.Socket.Off("autoUpdater-allowDowngrade-get-reply");
+                BridgeConnector.Off("autoUpdater-allowDowngrade-get-reply");
                 taskCompletionSource.SetResult((bool)result);
             });
 
-            BridgeConnector.Socket.Emit("autoUpdater-allowDowngrade-get");
+            BridgeConnector.Emit("autoUpdater-allowDowngrade-get");
 
             return taskCompletionSource.Task;
         }
@@ -113,7 +113,7 @@ namespace ElectronNET.API
         {
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-autoDownload-set", value);
+                BridgeConnector.Emit("autoUpdater-autoDownload-set", value);
             }
         }
 
@@ -126,7 +126,7 @@ namespace ElectronNET.API
         {
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-autoInstallOnAppQuit-set", value);
+                BridgeConnector.Emit("autoUpdater-autoInstallOnAppQuit-set", value);
             }
         }
 
@@ -140,7 +140,7 @@ namespace ElectronNET.API
         {
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-allowPrerelease-set", value);
+                BridgeConnector.Emit("autoUpdater-allowPrerelease-set", value);
             }
         }
 
@@ -152,7 +152,7 @@ namespace ElectronNET.API
         {
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-fullChangelog-set", value);
+                BridgeConnector.Emit("autoUpdater-fullChangelog-set", value);
             }
         }
 
@@ -165,7 +165,7 @@ namespace ElectronNET.API
         {
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-allowDowngrade-set", value);
+                BridgeConnector.Emit("autoUpdater-allowDowngrade-set", value);
             }
         }
 
@@ -176,13 +176,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("autoUpdater-updateConfigPath-get-reply", (result) =>
+            BridgeConnector.On<string>("autoUpdater-updateConfigPath-get-reply", (result) =>
             {
-                BridgeConnector.Socket.Off("autoUpdater-updateConfigPath-get-reply");
+                BridgeConnector.Off("autoUpdater-updateConfigPath-get-reply");
                 taskCompletionSource.SetResult(result.ToString());
             });
 
-            BridgeConnector.Socket.Emit("autoUpdater-updateConfigPath-get");
+            BridgeConnector.Emit("autoUpdater-updateConfigPath-get");
 
             return taskCompletionSource.Task;
         }
@@ -194,13 +194,12 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<SemVer>();
 
-            BridgeConnector.Socket.On("autoUpdater-currentVersion-get-reply", (result) =>
+            BridgeConnector.On<SemVer>("autoUpdater-currentVersion-get-reply", (version) =>
             {
-                BridgeConnector.Socket.Off("autoUpdater-currentVersion-get-reply");
-                SemVer version = ((JObject)result).ToObject<SemVer>();
+                BridgeConnector.Off("autoUpdater-currentVersion-get-reply");
                 taskCompletionSource.SetResult(version);
             });
-            BridgeConnector.Socket.Emit("autoUpdater-currentVersion-get");
+            BridgeConnector.Emit("autoUpdater-currentVersion-get");
 
             return taskCompletionSource.Task;
         }
@@ -213,12 +212,12 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("autoUpdater-channel-get-reply", (result) =>
+            BridgeConnector.On<string>("autoUpdater-channel-get-reply", (result) =>
             {
-                BridgeConnector.Socket.Off("autoUpdater-channel-get-reply");
+                BridgeConnector.Off("autoUpdater-channel-get-reply");
                 taskCompletionSource.SetResult(result.ToString());
             });
-            BridgeConnector.Socket.Emit("autoUpdater-channel-get");
+            BridgeConnector.Emit("autoUpdater-channel-get");
 
             return taskCompletionSource.Task;
         }
@@ -231,13 +230,12 @@ namespace ElectronNET.API
         public Task<Dictionary<string, string>> GetRequestHeadersAsync()
         {
             var taskCompletionSource = new TaskCompletionSource<Dictionary<string, string>>();
-            BridgeConnector.Socket.On("autoUpdater-requestHeaders-get-reply", (headers) =>
+            BridgeConnector.On<Dictionary<string, string>>("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.Off("autoUpdater-requestHeaders-get-reply");
+                taskCompletionSource.SetResult(headers);
             });
-            BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-get");
+            BridgeConnector.Emit("autoUpdater-requestHeaders-get");
             return taskCompletionSource.Task;
         }
 
@@ -248,7 +246,7 @@ namespace ElectronNET.API
         {
             set
             {
-                BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-set", JObject.FromObject(value, _jsonSerializer));
+                BridgeConnector.Emit("autoUpdater-requestHeaders-set", JObject.FromObject(value, _jsonSerializer));
             }
         }
 
@@ -261,12 +259,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;
             }
@@ -275,7 +273,7 @@ namespace ElectronNET.API
                 _error -= value;
 
                 if (_error == null)
-                    BridgeConnector.Socket.Off("autoUpdater-error" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-error" + GetHashCode());
             }
         }
 
@@ -290,12 +288,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;
             }
@@ -304,7 +302,7 @@ namespace ElectronNET.API
                 _checkingForUpdate -= value;
 
                 if (_checkingForUpdate == null)
-                    BridgeConnector.Socket.Off("autoUpdater-checking-for-update" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-checking-for-update" + GetHashCode());
             }
         }
 
@@ -320,12 +318,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;
             }
@@ -334,7 +332,7 @@ namespace ElectronNET.API
                 _updateAvailable -= value;
 
                 if (_updateAvailable == null)
-                    BridgeConnector.Socket.Off("autoUpdater-update-available" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-update-available" + GetHashCode());
             }
         }
 
@@ -349,12 +347,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;
             }
@@ -363,7 +361,7 @@ namespace ElectronNET.API
                 _updateNotAvailable -= value;
 
                 if (_updateNotAvailable == null)
-                    BridgeConnector.Socket.Off("autoUpdater-update-not-available" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-update-not-available" + GetHashCode());
             }
         }
 
@@ -378,12 +376,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;
             }
@@ -392,7 +390,7 @@ namespace ElectronNET.API
                 _downloadProgress -= value;
 
                 if (_downloadProgress == null)
-                    BridgeConnector.Socket.Off("autoUpdater-download-progress" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-download-progress" + GetHashCode());
             }
         }
 
@@ -407,12 +405,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;
             }
@@ -421,7 +419,7 @@ namespace ElectronNET.API
                 _updateDownloaded -= value;
 
                 if (_updateDownloaded == null)
-                    BridgeConnector.Socket.Off("autoUpdater-update-downloaded" + GetHashCode());
+                    BridgeConnector.Off("autoUpdater-update-downloaded" + GetHashCode());
             }
         }
 
@@ -460,30 +458,30 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
             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;
         }
@@ -499,33 +497,33 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
             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;
         }
@@ -541,7 +539,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.Emit("autoUpdaterQuitAndInstall", isSilent, isForceRunAfter);
         }
 
         /// <summary>
@@ -553,13 +551,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             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;
         }
@@ -573,13 +571,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             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;
         }
diff --git a/ElectronNET.API/BridgeConnector.cs b/ElectronNET.API/BridgeConnector.cs
index 08a8474..fa910fe 100644
--- a/ElectronNET.API/BridgeConnector.cs
+++ b/ElectronNET.API/BridgeConnector.cs
@@ -1,39 +1,65 @@
-using Quobject.SocketIoClientDotNet.Client;
-using System;
+using System;
+using SocketIOClient;
+using SocketIOClient.Newtonsoft.Json;
 
 namespace ElectronNET.API
 {
     internal static class BridgeConnector
     {
-        private static Socket _socket;
+        private static SocketIO _socket;
         private static object _syncRoot = new object();
 
-        public static Socket Socket
+
+        public static void Emit(string eventString, params object[] args) => Socket.EmitAsync(eventString, args);
+        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)    => Socket.On(eventString, (o) =>
+        {
+            Socket.Off(eventString);
+            fn(o.GetValue<T>(0));
+        });
+
+
+        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 NewtonsoftJsonSerializer(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");
                     }
                 }
 
@@ -41,4 +67,55 @@ namespace ElectronNET.API
             }
         }
     }
+
+    public interface IListener : System.IComparable<IListener>
+    {
+        int GetId();
+        void Call(params object[] args);
+    }
+
+    public class ListenerImpl : IListener
+    {
+        private static int id_counter = 0;
+        private int Id;
+        private readonly Action fn1;
+        private readonly Action<object> fn;
+
+        public ListenerImpl(Action<object> fn)
+        {
+
+            this.fn = fn;
+            this.Id = id_counter++;
+        }
+
+        public ListenerImpl(Action fn)
+        {
+
+            this.fn1 = fn;
+            this.Id = id_counter++;
+        }
+
+        public void Call(params object[] args)
+        {
+            if (fn != null)
+            {
+                var arg = args.Length > 0 ? args[0] : null;
+                fn(arg);
+            }
+            else
+            {
+                fn1();
+            }
+        }
+
+        public int CompareTo(IListener other)
+        {
+            return this.GetId().CompareTo(other.GetId());
+        }
+
+        public int GetId()
+        {
+            return Id;
+        }
+    }
 }
diff --git a/ElectronNET.API/BrowserView.cs b/ElectronNET.API/BrowserView.cs
index 868c09f..82b6daf 100644
--- a/ElectronNET.API/BrowserView.cs
+++ b/ElectronNET.API/BrowserView.cs
@@ -35,20 +35,20 @@ namespace ElectronNET.API
         {
                 var taskCompletionSource = new TaskCompletionSource<Rectangle>();
 
-                BridgeConnector.Socket.On("browserView-getBounds-reply", (result) =>
+                BridgeConnector.On<Rectangle>("browserView-getBounds-reply", (result) =>
                 {
-                    BridgeConnector.Socket.Off("browserView-getBounds-reply");
-                    taskCompletionSource.SetResult((Rectangle)result);
+                    BridgeConnector.Off("browserView-getBounds-reply");
+                    taskCompletionSource.SetResult(result);
                 });
 
-                BridgeConnector.Socket.Emit("browserView-getBounds", Id);
+                BridgeConnector.Emit("browserView-getBounds", Id);
 
             return taskCompletionSource.Task;
         }
 
         public void SetBounds(Rectangle value)
         {
-            BridgeConnector.Socket.Emit("browserView-setBounds", Id, JObject.FromObject(value, _jsonSerializer));
+            BridgeConnector.Emit("browserView-setBounds", Id, JObject.FromObject(value, _jsonSerializer));
         }
 
         /// <summary>
@@ -69,7 +69,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, JObject.FromObject(options, _jsonSerializer));
         }
 
         /// <summary>
@@ -80,7 +80,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()
diff --git a/ElectronNET.API/BrowserWindow.cs b/ElectronNET.API/BrowserWindow.cs
index 2c4590a..b08081c 100644
--- a/ElectronNET.API/BrowserWindow.cs
+++ b/ElectronNET.API/BrowserWindow.cs
@@ -34,12 +34,12 @@ namespace ElectronNET.API
             {
                 if (_readyToShow == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-ready-to-show" + Id, () =>
+                    BridgeConnector.On("browserWindow-ready-to-show" + Id, () =>
                     {
                         _readyToShow();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-ready-to-show", Id);
+                    BridgeConnector.Emit("register-browserWindow-ready-to-show", Id);
                 }
                 _readyToShow += value;
             }
@@ -48,7 +48,7 @@ namespace ElectronNET.API
                 _readyToShow -= value;
 
                 if (_readyToShow == null)
-                    BridgeConnector.Socket.Off("browserWindow-ready-to-show" + Id);
+                    BridgeConnector.Off("browserWindow-ready-to-show" + Id);
             }
         }
 
@@ -63,12 +63,12 @@ namespace ElectronNET.API
             {
                 if (_pageTitleUpdated == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-page-title-updated" + Id, (title) =>
+                    BridgeConnector.On<string>("browserWindow-page-title-updated" + Id, (title) =>
                     {
-                        _pageTitleUpdated(title.ToString());
+                        _pageTitleUpdated(title);
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-page-title-updated", Id);
+                    BridgeConnector.Emit("register-browserWindow-page-title-updated", Id);
                 }
                 _pageTitleUpdated += value;
             }
@@ -77,7 +77,7 @@ namespace ElectronNET.API
                 _pageTitleUpdated -= value;
 
                 if (_pageTitleUpdated == null)
-                    BridgeConnector.Socket.Off("browserWindow-page-title-updated" + Id);
+                    BridgeConnector.Off("browserWindow-page-title-updated" + Id);
             }
         }
 
@@ -92,12 +92,12 @@ namespace ElectronNET.API
             {
                 if (_close == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-close" + Id, () =>
+                    BridgeConnector.On("browserWindow-close" + Id, () =>
                     {
                         _close();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-close", Id);
+                    BridgeConnector.Emit("register-browserWindow-close", Id);
                 }
                 _close += value;
             }
@@ -106,7 +106,7 @@ namespace ElectronNET.API
                 _close -= value;
 
                 if (_close == null)
-                    BridgeConnector.Socket.Off("browserWindow-close" + Id);
+                    BridgeConnector.Off("browserWindow-close" + Id);
             }
         }
 
@@ -123,12 +123,12 @@ namespace ElectronNET.API
             {
                 if (_closed == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-closed" + Id, () =>
+                    BridgeConnector.On("browserWindow-closed" + Id, () =>
                     {
                         _closed();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-closed", Id);
+                    BridgeConnector.Emit("register-browserWindow-closed", Id);
                 }
                 _closed += value;
             }
@@ -137,7 +137,7 @@ namespace ElectronNET.API
                 _closed -= value;
 
                 if (_closed == null)
-                    BridgeConnector.Socket.Off("browserWindow-closed" + Id);
+                    BridgeConnector.Off("browserWindow-closed" + Id);
             }
         }
 
@@ -152,12 +152,12 @@ namespace ElectronNET.API
             {
                 if (_sessionEnd == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-session-end" + Id, () =>
+                    BridgeConnector.On("browserWindow-session-end" + Id, () =>
                     {
                         _sessionEnd();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-session-end", Id);
+                    BridgeConnector.Emit("register-browserWindow-session-end", Id);
                 }
                 _sessionEnd += value;
             }
@@ -166,7 +166,7 @@ namespace ElectronNET.API
                 _sessionEnd -= value;
 
                 if (_sessionEnd == null)
-                    BridgeConnector.Socket.Off("browserWindow-session-end" + Id);
+                    BridgeConnector.Off("browserWindow-session-end" + Id);
             }
         }
 
@@ -181,12 +181,12 @@ namespace ElectronNET.API
             {
                 if (_unresponsive == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-unresponsive" + Id, () =>
+                    BridgeConnector.On("browserWindow-unresponsive" + Id, () =>
                     {
                         _unresponsive();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-unresponsive", Id);
+                    BridgeConnector.Emit("register-browserWindow-unresponsive", Id);
                 }
                 _unresponsive += value;
             }
@@ -195,7 +195,7 @@ namespace ElectronNET.API
                 _unresponsive -= value;
 
                 if (_unresponsive == null)
-                    BridgeConnector.Socket.Off("browserWindow-unresponsive" + Id);
+                    BridgeConnector.Off("browserWindow-unresponsive" + Id);
             }
         }
 
@@ -210,12 +210,12 @@ namespace ElectronNET.API
             {
                 if (_responsive == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-responsive" + Id, () =>
+                    BridgeConnector.On("browserWindow-responsive" + Id, () =>
                     {
                         _responsive();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-responsive", Id);
+                    BridgeConnector.Emit("register-browserWindow-responsive", Id);
                 }
                 _responsive += value;
             }
@@ -224,7 +224,7 @@ namespace ElectronNET.API
                 _responsive -= value;
 
                 if (_responsive == null)
-                    BridgeConnector.Socket.Off("browserWindow-responsive" + Id);
+                    BridgeConnector.Off("browserWindow-responsive" + Id);
             }
         }
 
@@ -239,12 +239,12 @@ namespace ElectronNET.API
             {
                 if (_blur == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-blur" + Id, () =>
+                    BridgeConnector.On("browserWindow-blur" + Id, () =>
                     {
                         _blur();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-blur", Id);
+                    BridgeConnector.Emit("register-browserWindow-blur", Id);
                 }
                 _blur += value;
             }
@@ -253,7 +253,7 @@ namespace ElectronNET.API
                 _blur -= value;
 
                 if (_blur == null)
-                    BridgeConnector.Socket.Off("browserWindow-blur" + Id);
+                    BridgeConnector.Off("browserWindow-blur" + Id);
             }
         }
 
@@ -268,12 +268,12 @@ namespace ElectronNET.API
             {
                 if (_focus == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-focus" + Id, () =>
+                    BridgeConnector.On("browserWindow-focus" + Id, () =>
                     {
                         _focus();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-focus", Id);
+                    BridgeConnector.Emit("register-browserWindow-focus", Id);
                 }
                 _focus += value;
             }
@@ -282,7 +282,7 @@ namespace ElectronNET.API
                 _focus -= value;
 
                 if (_focus == null)
-                    BridgeConnector.Socket.Off("browserWindow-focus" + Id);
+                    BridgeConnector.Off("browserWindow-focus" + Id);
             }
         }
 
@@ -297,12 +297,12 @@ namespace ElectronNET.API
             {
                 if (_show == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-show" + Id, () =>
+                    BridgeConnector.On("browserWindow-show" + Id, () =>
                     {
                         _show();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-show", Id);
+                    BridgeConnector.Emit("register-browserWindow-show", Id);
                 }
                 _show += value;
             }
@@ -311,7 +311,7 @@ namespace ElectronNET.API
                 _show -= value;
 
                 if (_show == null)
-                    BridgeConnector.Socket.Off("browserWindow-show" + Id);
+                    BridgeConnector.Off("browserWindow-show" + Id);
             }
         }
 
@@ -326,12 +326,12 @@ namespace ElectronNET.API
             {
                 if (_hide == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-hide" + Id, () =>
+                    BridgeConnector.On("browserWindow-hide" + Id, () =>
                     {
                         _hide();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-hide", Id);
+                    BridgeConnector.Emit("register-browserWindow-hide", Id);
                 }
                 _hide += value;
             }
@@ -340,7 +340,7 @@ namespace ElectronNET.API
                 _hide -= value;
 
                 if (_hide == null)
-                    BridgeConnector.Socket.Off("browserWindow-hide" + Id);
+                    BridgeConnector.Off("browserWindow-hide" + Id);
             }
         }
 
@@ -355,12 +355,12 @@ namespace ElectronNET.API
             {
                 if (_maximize == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-maximize" + Id, () =>
+                    BridgeConnector.On("browserWindow-maximize" + Id, () =>
                     {
                         _maximize();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-maximize", Id);
+                    BridgeConnector.Emit("register-browserWindow-maximize", Id);
                 }
                 _maximize += value;
             }
@@ -369,7 +369,7 @@ namespace ElectronNET.API
                 _maximize -= value;
 
                 if (_maximize == null)
-                    BridgeConnector.Socket.Off("browserWindow-maximize" + Id);
+                    BridgeConnector.Off("browserWindow-maximize" + Id);
             }
         }
 
@@ -384,12 +384,12 @@ namespace ElectronNET.API
             {
                 if (_unmaximize == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-unmaximize" + Id, () =>
+                    BridgeConnector.On("browserWindow-unmaximize" + Id, () =>
                     {
                         _unmaximize();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-unmaximize", Id);
+                    BridgeConnector.Emit("register-browserWindow-unmaximize", Id);
                 }
                 _unmaximize += value;
             }
@@ -398,7 +398,7 @@ namespace ElectronNET.API
                 _unmaximize -= value;
 
                 if (_unmaximize == null)
-                    BridgeConnector.Socket.Off("browserWindow-unmaximize" + Id);
+                    BridgeConnector.Off("browserWindow-unmaximize" + Id);
             }
         }
 
@@ -413,12 +413,12 @@ namespace ElectronNET.API
             {
                 if (_minimize == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-minimize" + Id, () =>
+                    BridgeConnector.On("browserWindow-minimize" + Id, () =>
                     {
                         _minimize();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-minimize", Id);
+                    BridgeConnector.Emit("register-browserWindow-minimize", Id);
                 }
                 _minimize += value;
             }
@@ -427,7 +427,7 @@ namespace ElectronNET.API
                 _minimize -= value;
 
                 if (_minimize == null)
-                    BridgeConnector.Socket.Off("browserWindow-minimize" + Id);
+                    BridgeConnector.Off("browserWindow-minimize" + Id);
             }
         }
 
@@ -442,12 +442,12 @@ namespace ElectronNET.API
             {
                 if (_restore == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-restore" + Id, () =>
+                    BridgeConnector.On("browserWindow-restore" + Id, () =>
                     {
                         _restore();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-restore", Id);
+                    BridgeConnector.Emit("register-browserWindow-restore", Id);
                 }
                 _restore += value;
             }
@@ -456,7 +456,7 @@ namespace ElectronNET.API
                 _restore -= value;
 
                 if (_restore == null)
-                    BridgeConnector.Socket.Off("browserWindow-restore" + Id);
+                    BridgeConnector.Off("browserWindow-restore" + Id);
             }
         }
 
@@ -471,12 +471,12 @@ namespace ElectronNET.API
             {
                 if (_resize == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-resize" + Id, () =>
+                    BridgeConnector.On("browserWindow-resize" + Id, () =>
                     {
                         _resize();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-resize", Id);
+                    BridgeConnector.Emit("register-browserWindow-resize", Id);
                 }
                 _resize += value;
             }
@@ -485,7 +485,7 @@ namespace ElectronNET.API
                 _resize -= value;
 
                 if (_resize == null)
-                    BridgeConnector.Socket.Off("browserWindow-resize" + Id);
+                    BridgeConnector.Off("browserWindow-resize" + Id);
             }
         }
 
@@ -502,12 +502,12 @@ namespace ElectronNET.API
             {
                 if (_move == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-move" + Id, () =>
+                    BridgeConnector.On("browserWindow-move" + Id, () =>
                     {
                         _move();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-move", Id);
+                    BridgeConnector.Emit("register-browserWindow-move", Id);
                 }
                 _move += value;
             }
@@ -516,7 +516,7 @@ namespace ElectronNET.API
                 _move -= value;
 
                 if (_move == null)
-                    BridgeConnector.Socket.Off("browserWindow-move" + Id);
+                    BridgeConnector.Off("browserWindow-move" + Id);
             }
         }
 
@@ -531,12 +531,12 @@ namespace ElectronNET.API
             {
                 if (_moved == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-moved" + Id, () =>
+                    BridgeConnector.On("browserWindow-moved" + Id, () =>
                     {
                         _moved();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-moved", Id);
+                    BridgeConnector.Emit("register-browserWindow-moved", Id);
                 }
                 _moved += value;
             }
@@ -545,7 +545,7 @@ namespace ElectronNET.API
                 _moved -= value;
 
                 if (_moved == null)
-                    BridgeConnector.Socket.Off("browserWindow-moved" + Id);
+                    BridgeConnector.Off("browserWindow-moved" + Id);
             }
         }
 
@@ -560,12 +560,12 @@ namespace ElectronNET.API
             {
                 if (_enterFullScreen == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-enter-full-screen" + Id, () =>
+                    BridgeConnector.On("browserWindow-enter-full-screen" + Id, () =>
                     {
                         _enterFullScreen();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-enter-full-screen", Id);
+                    BridgeConnector.Emit("register-browserWindow-enter-full-screen", Id);
                 }
                 _enterFullScreen += value;
             }
@@ -574,7 +574,7 @@ namespace ElectronNET.API
                 _enterFullScreen -= value;
 
                 if (_enterFullScreen == null)
-                    BridgeConnector.Socket.Off("browserWindow-enter-full-screen" + Id);
+                    BridgeConnector.Off("browserWindow-enter-full-screen" + Id);
             }
         }
 
@@ -589,12 +589,12 @@ namespace ElectronNET.API
             {
                 if (_leaveFullScreen == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-leave-full-screen" + Id, () =>
+                    BridgeConnector.On("browserWindow-leave-full-screen" + Id, () =>
                     {
                         _leaveFullScreen();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-leave-full-screen", Id);
+                    BridgeConnector.Emit("register-browserWindow-leave-full-screen", Id);
                 }
                 _leaveFullScreen += value;
             }
@@ -603,7 +603,7 @@ namespace ElectronNET.API
                 _leaveFullScreen -= value;
 
                 if (_leaveFullScreen == null)
-                    BridgeConnector.Socket.Off("browserWindow-leave-full-screen" + Id);
+                    BridgeConnector.Off("browserWindow-leave-full-screen" + Id);
             }
         }
 
@@ -618,12 +618,12 @@ namespace ElectronNET.API
             {
                 if (_enterHtmlFullScreen == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-enter-html-full-screen" + Id, () =>
+                    BridgeConnector.On("browserWindow-enter-html-full-screen" + Id, () =>
                     {
                         _enterHtmlFullScreen();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-enter-html-full-screen", Id);
+                    BridgeConnector.Emit("register-browserWindow-enter-html-full-screen", Id);
                 }
                 _enterHtmlFullScreen += value;
             }
@@ -632,7 +632,7 @@ namespace ElectronNET.API
                 _enterHtmlFullScreen -= value;
 
                 if (_enterHtmlFullScreen == null)
-                    BridgeConnector.Socket.Off("browserWindow-enter-html-full-screen" + Id);
+                    BridgeConnector.Off("browserWindow-enter-html-full-screen" + Id);
             }
         }
 
@@ -647,12 +647,12 @@ namespace ElectronNET.API
             {
                 if (_leaveHtmlFullScreen == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-leave-html-full-screen" + Id, () =>
+                    BridgeConnector.On("browserWindow-leave-html-full-screen" + Id, () =>
                     {
                         _leaveHtmlFullScreen();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-leave-html-full-screen", Id);
+                    BridgeConnector.Emit("register-browserWindow-leave-html-full-screen", Id);
                 }
                 _leaveHtmlFullScreen += value;
             }
@@ -661,7 +661,7 @@ namespace ElectronNET.API
                 _leaveHtmlFullScreen -= value;
 
                 if (_leaveHtmlFullScreen == null)
-                    BridgeConnector.Socket.Off("browserWindow-leave-html-full-screen" + Id);
+                    BridgeConnector.Off("browserWindow-leave-html-full-screen" + Id);
             }
         }
 
@@ -682,12 +682,12 @@ namespace ElectronNET.API
             {
                 if (_appCommand == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-app-command" + Id, (command) =>
+                    BridgeConnector.On<string>("browserWindow-app-command" + Id, (command) =>
                     {
-                        _appCommand(command.ToString());
+                        _appCommand(command);
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-app-command", Id);
+                    BridgeConnector.Emit("register-browserWindow-app-command", Id);
                 }
                 _appCommand += value;
             }
@@ -696,7 +696,7 @@ namespace ElectronNET.API
                 _appCommand -= value;
 
                 if (_appCommand == null)
-                    BridgeConnector.Socket.Off("browserWindow-app-command" + Id);
+                    BridgeConnector.Off("browserWindow-app-command" + Id);
             }
         }
 
@@ -711,12 +711,12 @@ namespace ElectronNET.API
             {
                 if (_scrollTouchBegin == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-scroll-touch-begin" + Id, () =>
+                    BridgeConnector.On("browserWindow-scroll-touch-begin" + Id, () =>
                     {
                         _scrollTouchBegin();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-scroll-touch-begin", Id);
+                    BridgeConnector.Emit("register-browserWindow-scroll-touch-begin", Id);
                 }
                 _scrollTouchBegin += value;
             }
@@ -725,7 +725,7 @@ namespace ElectronNET.API
                 _scrollTouchBegin -= value;
 
                 if (_scrollTouchBegin == null)
-                    BridgeConnector.Socket.Off("browserWindow-scroll-touch-begin" + Id);
+                    BridgeConnector.Off("browserWindow-scroll-touch-begin" + Id);
             }
         }
 
@@ -740,12 +740,12 @@ namespace ElectronNET.API
             {
                 if (_scrollTouchEnd == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-scroll-touch-end" + Id, () =>
+                    BridgeConnector.On("browserWindow-scroll-touch-end" + Id, () =>
                     {
                         _scrollTouchEnd();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-scroll-touch-end", Id);
+                    BridgeConnector.Emit("register-browserWindow-scroll-touch-end", Id);
                 }
                 _scrollTouchEnd += value;
             }
@@ -754,7 +754,7 @@ namespace ElectronNET.API
                 _scrollTouchEnd -= value;
 
                 if (_scrollTouchEnd == null)
-                    BridgeConnector.Socket.Off("browserWindow-scroll-touch-end" + Id);
+                    BridgeConnector.Off("browserWindow-scroll-touch-end" + Id);
             }
         }
 
@@ -769,12 +769,12 @@ namespace ElectronNET.API
             {
                 if (_scrollTouchEdge == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-scroll-touch-edge" + Id, () =>
+                    BridgeConnector.On("browserWindow-scroll-touch-edge" + Id, () =>
                     {
                         _scrollTouchEdge();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-scroll-touch-edge", Id);
+                    BridgeConnector.Emit("register-browserWindow-scroll-touch-edge", Id);
                 }
                 _scrollTouchEdge += value;
             }
@@ -783,7 +783,7 @@ namespace ElectronNET.API
                 _scrollTouchEdge -= value;
 
                 if (_scrollTouchEdge == null)
-                    BridgeConnector.Socket.Off("browserWindow-scroll-touch-edge" + Id);
+                    BridgeConnector.Off("browserWindow-scroll-touch-edge" + Id);
             }
         }
 
@@ -798,12 +798,12 @@ namespace ElectronNET.API
             {
                 if (_swipe == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-swipe" + Id, (direction) =>
+                    BridgeConnector.On<string>("browserWindow-swipe" + Id, (direction) =>
                     {
-                        _swipe(direction.ToString());
+                        _swipe(direction);
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-swipe", Id);
+                    BridgeConnector.Emit("register-browserWindow-swipe", Id);
                 }
                 _swipe += value;
             }
@@ -812,7 +812,7 @@ namespace ElectronNET.API
                 _swipe -= value;
 
                 if (_swipe == null)
-                    BridgeConnector.Socket.Off("browserWindow-swipe" + Id);
+                    BridgeConnector.Off("browserWindow-swipe" + Id);
             }
         }
 
@@ -827,12 +827,12 @@ namespace ElectronNET.API
             {
                 if (_sheetBegin == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-sheet-begin" + Id, () =>
+                    BridgeConnector.On("browserWindow-sheet-begin" + Id, () =>
                     {
                         _sheetBegin();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-sheet-begin", Id);
+                    BridgeConnector.Emit("register-browserWindow-sheet-begin", Id);
                 }
                 _sheetBegin += value;
             }
@@ -841,7 +841,7 @@ namespace ElectronNET.API
                 _sheetBegin -= value;
 
                 if (_sheetBegin == null)
-                    BridgeConnector.Socket.Off("browserWindow-sheet-begin" + Id);
+                    BridgeConnector.Off("browserWindow-sheet-begin" + Id);
             }
         }
 
@@ -856,12 +856,12 @@ namespace ElectronNET.API
             {
                 if (_sheetEnd == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-sheet-end" + Id, () =>
+                    BridgeConnector.On("browserWindow-sheet-end" + Id, () =>
                     {
                         _sheetEnd();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-sheet-end", Id);
+                    BridgeConnector.Emit("register-browserWindow-sheet-end", Id);
                 }
                 _sheetEnd += value;
             }
@@ -870,7 +870,7 @@ namespace ElectronNET.API
                 _sheetEnd -= value;
 
                 if (_sheetEnd == null)
-                    BridgeConnector.Socket.Off("browserWindow-sheet-end" + Id);
+                    BridgeConnector.Off("browserWindow-sheet-end" + Id);
             }
         }
 
@@ -885,12 +885,12 @@ namespace ElectronNET.API
             {
                 if (_newWindowForTab == null)
                 {
-                    BridgeConnector.Socket.On("browserWindow-new-window-for-tab" + Id, () =>
+                    BridgeConnector.On("browserWindow-new-window-for-tab" + Id, () =>
                     {
                         _newWindowForTab();
                     });
 
-                    BridgeConnector.Socket.Emit("register-browserWindow-new-window-for-tab", Id);
+                    BridgeConnector.Emit("register-browserWindow-new-window-for-tab", Id);
                 }
                 _newWindowForTab += value;
             }
@@ -899,7 +899,7 @@ namespace ElectronNET.API
                 _newWindowForTab -= value;
 
                 if (_newWindowForTab == null)
-                    BridgeConnector.Socket.Off("browserWindow-new-window-for-tab" + Id);
+                    BridgeConnector.Off("browserWindow-new-window-for-tab" + Id);
             }
         }
 
@@ -917,7 +917,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Destroy()
         {
-            BridgeConnector.Socket.Emit("browserWindowDestroy", Id);
+            BridgeConnector.Emit("browserWindowDestroy", Id);
         }
 
         /// <summary>
@@ -926,7 +926,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Close()
         {
-            BridgeConnector.Socket.Emit("browserWindowClose", Id);
+            BridgeConnector.Emit("browserWindowClose", Id);
         }
 
         /// <summary>
@@ -934,7 +934,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Focus()
         {
-            BridgeConnector.Socket.Emit("browserWindowFocus", Id);
+            BridgeConnector.Emit("browserWindowFocus", Id);
         }
 
         /// <summary>
@@ -942,7 +942,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Blur()
         {
-            BridgeConnector.Socket.Emit("browserWindowBlur", Id);
+            BridgeConnector.Emit("browserWindowBlur", Id);
         }
 
         /// <summary>
@@ -953,13 +953,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isFocused-completed", (isFocused) => {
-                BridgeConnector.Socket.Off("browserWindow-isFocused-completed");
+            BridgeConnector.On<bool>("browserWindow-isFocused-completed", (isFocused) => {
+                BridgeConnector.Off("browserWindow-isFocused-completed");
 
                 taskCompletionSource.SetResult((bool)isFocused);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsFocused", Id);
+            BridgeConnector.Emit("browserWindowIsFocused", Id);
 
             return taskCompletionSource.Task;
         }
@@ -972,13 +972,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isDestroyed-completed", (isDestroyed) => {
-                BridgeConnector.Socket.Off("browserWindow-isDestroyed-completed");
+            BridgeConnector.On<bool>("browserWindow-isDestroyed-completed", (isDestroyed) => {
+                BridgeConnector.Off("browserWindow-isDestroyed-completed");
 
                 taskCompletionSource.SetResult((bool)isDestroyed);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsDestroyed", Id);
+            BridgeConnector.Emit("browserWindowIsDestroyed", Id);
 
             return taskCompletionSource.Task;
         }
@@ -988,7 +988,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Show()
         {
-            BridgeConnector.Socket.Emit("browserWindowShow", Id);
+            BridgeConnector.Emit("browserWindowShow", Id);
         }
 
         /// <summary>
@@ -996,7 +996,7 @@ namespace ElectronNET.API
         /// </summary>
         public void ShowInactive()
         {
-            BridgeConnector.Socket.Emit("browserWindowShowInactive", Id);
+            BridgeConnector.Emit("browserWindowShowInactive", Id);
         }
 
         /// <summary>
@@ -1004,7 +1004,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Hide()
         {
-            BridgeConnector.Socket.Emit("browserWindowHide", Id);
+            BridgeConnector.Emit("browserWindowHide", Id);
         }
 
         /// <summary>
@@ -1015,13 +1015,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isVisible-completed", (isVisible) => {
-                BridgeConnector.Socket.Off("browserWindow-isVisible-completed");
+            BridgeConnector.On<bool>("browserWindow-isVisible-completed", (isVisible) => {
+                BridgeConnector.Off("browserWindow-isVisible-completed");
 
                 taskCompletionSource.SetResult((bool)isVisible);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsVisible", Id);
+            BridgeConnector.Emit("browserWindowIsVisible", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1034,13 +1034,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isModal-completed", (isModal) => {
-                BridgeConnector.Socket.Off("browserWindow-isModal-completed");
+            BridgeConnector.On<bool>("browserWindow-isModal-completed", (isModal) => {
+                BridgeConnector.Off("browserWindow-isModal-completed");
 
                 taskCompletionSource.SetResult((bool)isModal);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsModal", Id);
+            BridgeConnector.Emit("browserWindowIsModal", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1050,7 +1050,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Maximize()
         {
-            BridgeConnector.Socket.Emit("browserWindowMaximize", Id);
+            BridgeConnector.Emit("browserWindowMaximize", Id);
         }
 
         /// <summary>
@@ -1058,7 +1058,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Unmaximize()
         {
-            BridgeConnector.Socket.Emit("browserWindowUnmaximize", Id);
+            BridgeConnector.Emit("browserWindowUnmaximize", Id);
         }
 
         /// <summary>
@@ -1069,13 +1069,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isMaximized-completed", (isMaximized) => {
-                BridgeConnector.Socket.Off("browserWindow-isMaximized-completed");
+            BridgeConnector.On<bool>("browserWindow-isMaximized-completed", (isMaximized) => {
+                BridgeConnector.Off("browserWindow-isMaximized-completed");
 
                 taskCompletionSource.SetResult((bool)isMaximized);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsMaximized", Id);
+            BridgeConnector.Emit("browserWindowIsMaximized", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1085,7 +1085,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Minimize()
         {
-            BridgeConnector.Socket.Emit("browserWindowMinimize", Id);
+            BridgeConnector.Emit("browserWindowMinimize", Id);
         }
 
         /// <summary>
@@ -1093,7 +1093,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Restore()
         {
-            BridgeConnector.Socket.Emit("browserWindowRestore", Id);
+            BridgeConnector.Emit("browserWindowRestore", Id);
         }
 
         /// <summary>
@@ -1104,13 +1104,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isMinimized-completed", (isMinimized) => {
-                BridgeConnector.Socket.Off("browserWindow-isMinimized-completed");
+            BridgeConnector.On<bool>("browserWindow-isMinimized-completed", (isMinimized) => {
+                BridgeConnector.Off("browserWindow-isMinimized-completed");
 
                 taskCompletionSource.SetResult((bool)isMinimized);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsMinimized", Id);
+            BridgeConnector.Emit("browserWindowIsMinimized", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1120,7 +1120,7 @@ namespace ElectronNET.API
         /// </summary>
         public void SetFullScreen(bool flag)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetFullScreen", Id, flag);
+            BridgeConnector.Emit("browserWindowSetFullScreen", Id, flag);
         }
 
         /// <summary>
@@ -1131,13 +1131,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isFullScreen-completed", (isFullScreen) => {
-                BridgeConnector.Socket.Off("browserWindow-isFullScreen-completed");
+            BridgeConnector.On<bool>("browserWindow-isFullScreen-completed", (isFullScreen) => {
+                BridgeConnector.Off("browserWindow-isFullScreen-completed");
 
                 taskCompletionSource.SetResult((bool)isFullScreen);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsFullScreen", Id);
+            BridgeConnector.Emit("browserWindowIsFullScreen", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1158,7 +1158,7 @@ namespace ElectronNET.API
         /// <param name="extraSize">The extra size not to be included while maintaining the aspect ratio.</param>
         public void SetAspectRatio(int aspectRatio, Size extraSize)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetAspectRatio", Id, aspectRatio, JObject.FromObject(extraSize, _jsonSerializer));
+            BridgeConnector.Emit("browserWindowSetAspectRatio", Id, aspectRatio, JObject.FromObject(extraSize, _jsonSerializer));
         }
 
         /// <summary>
@@ -1169,7 +1169,7 @@ namespace ElectronNET.API
         /// file to open.</param>
         public void PreviewFile(string path)
         {
-            BridgeConnector.Socket.Emit("browserWindowPreviewFile", Id, path);
+            BridgeConnector.Emit("browserWindowPreviewFile", Id, path);
         }
 
         /// <summary>
@@ -1182,7 +1182,7 @@ namespace ElectronNET.API
         /// purely visual and does not affect the content type of the file. Defaults to path.</param>
         public void PreviewFile(string path, string displayname)
         {
-            BridgeConnector.Socket.Emit("browserWindowPreviewFile", Id, path, displayname);
+            BridgeConnector.Emit("browserWindowPreviewFile", Id, path, displayname);
         }
 
         /// <summary>
@@ -1190,7 +1190,7 @@ namespace ElectronNET.API
         /// </summary>
         public void CloseFilePreview()
         {
-            BridgeConnector.Socket.Emit("browserWindowCloseFilePreview", Id);
+            BridgeConnector.Emit("browserWindowCloseFilePreview", Id);
         }
 
         /// <summary>
@@ -1199,7 +1199,7 @@ namespace ElectronNET.API
         /// <param name="bounds"></param>
         public void SetBounds(Rectangle bounds)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetBounds", Id, JObject.FromObject(bounds, _jsonSerializer));
+            BridgeConnector.Emit("browserWindowSetBounds", Id, JObject.FromObject(bounds, _jsonSerializer));
         }
 
         /// <summary>
@@ -1209,7 +1209,7 @@ namespace ElectronNET.API
         /// <param name="animate"></param>
         public void SetBounds(Rectangle bounds, bool animate)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetBounds", Id, JObject.FromObject(bounds, _jsonSerializer), animate);
+            BridgeConnector.Emit("browserWindowSetBounds", Id, JObject.FromObject(bounds, _jsonSerializer), animate);
         }
 
         /// <summary>
@@ -1220,13 +1220,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<Rectangle>();
 
-            BridgeConnector.Socket.On("browserWindow-getBounds-completed", (getBounds) => {
-                BridgeConnector.Socket.Off("browserWindow-getBounds-completed");
+            BridgeConnector.On<Rectangle>("browserWindow-getBounds-completed", (getBounds) => {
+                BridgeConnector.Off("browserWindow-getBounds-completed");
 
-                taskCompletionSource.SetResult(((JObject)getBounds).ToObject<Rectangle>());
+                taskCompletionSource.SetResult(getBounds);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetBounds", Id);
+            BridgeConnector.Emit("browserWindowGetBounds", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1237,7 +1237,7 @@ namespace ElectronNET.API
         /// <param name="bounds"></param>
         public void SetContentBounds(Rectangle bounds)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetContentBounds", Id, JObject.FromObject(bounds, _jsonSerializer));
+            BridgeConnector.Emit("browserWindowSetContentBounds", Id, JObject.FromObject(bounds, _jsonSerializer));
         }
 
         /// <summary>
@@ -1247,7 +1247,7 @@ namespace ElectronNET.API
         /// <param name="animate"></param>
         public void SetContentBounds(Rectangle bounds, bool animate)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetContentBounds", Id, JObject.FromObject(bounds, _jsonSerializer), animate);
+            BridgeConnector.Emit("browserWindowSetContentBounds", Id, JObject.FromObject(bounds, _jsonSerializer), animate);
         }
 
         /// <summary>
@@ -1258,13 +1258,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<Rectangle>();
 
-            BridgeConnector.Socket.On("browserWindow-getContentBounds-completed", (getContentBounds) => {
-                BridgeConnector.Socket.Off("browserWindow-getContentBounds-completed");
+            BridgeConnector.On<Rectangle>("browserWindow-getContentBounds-completed", (getContentBounds) => {
+                BridgeConnector.Off("browserWindow-getContentBounds-completed");
 
-                taskCompletionSource.SetResult(((JObject)getContentBounds).ToObject<Rectangle>());
+                taskCompletionSource.SetResult(getContentBounds);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetContentBounds", Id);
+            BridgeConnector.Emit("browserWindowGetContentBounds", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1276,7 +1276,7 @@ namespace ElectronNET.API
         /// <param name="height"></param>
         public void SetSize(int width, int height)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetSize", Id, width, height);
+            BridgeConnector.Emit("browserWindowSetSize", Id, width, height);
         }
 
         /// <summary>
@@ -1287,7 +1287,7 @@ namespace ElectronNET.API
         /// <param name="animate"></param>
         public void SetSize(int width, int height, bool animate)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetSize", Id, width, height, animate);
+            BridgeConnector.Emit("browserWindowSetSize", Id, width, height, animate);
         }
 
         /// <summary>
@@ -1298,13 +1298,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<int[]>();
 
-            BridgeConnector.Socket.On("browserWindow-getSize-completed", (size) => {
-                BridgeConnector.Socket.Off("browserWindow-getSize-completed");
+            BridgeConnector.On<int[]>("browserWindow-getSize-completed", (size) => {
+                BridgeConnector.Off("browserWindow-getSize-completed");
 
-                taskCompletionSource.SetResult(((JArray)size).ToObject<int[]>());
+                taskCompletionSource.SetResult(size);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetSize", Id);
+            BridgeConnector.Emit("browserWindowGetSize", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1316,7 +1316,7 @@ namespace ElectronNET.API
         /// <param name="height"></param>
         public void SetContentSize(int width, int height)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetContentSize", Id, width, height);
+            BridgeConnector.Emit("browserWindowSetContentSize", Id, width, height);
         }
 
         /// <summary>
@@ -1327,7 +1327,7 @@ namespace ElectronNET.API
         /// <param name="animate"></param>
         public void SetContentSize(int width, int height, bool animate)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetContentSize", Id, width, height, animate);
+            BridgeConnector.Emit("browserWindowSetContentSize", Id, width, height, animate);
         }
 
         /// <summary>
@@ -1338,13 +1338,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<int[]>();
 
-            BridgeConnector.Socket.On("browserWindow-getContentSize-completed", (size) => {
-                BridgeConnector.Socket.Off("browserWindow-getContentSize-completed");
+            BridgeConnector.On<int[]>("browserWindow-getContentSize-completed", (size) => {
+                BridgeConnector.Off("browserWindow-getContentSize-completed");
 
-                taskCompletionSource.SetResult(((JArray)size).ToObject<int[]>());
+                taskCompletionSource.SetResult(size);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetContentSize", Id);
+            BridgeConnector.Emit("browserWindowGetContentSize", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1356,7 +1356,7 @@ namespace ElectronNET.API
         /// <param name="height"></param>
         public void SetMinimumSize(int width, int height)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetMinimumSize", Id, width, height);
+            BridgeConnector.Emit("browserWindowSetMinimumSize", Id, width, height);
         }
 
         /// <summary>
@@ -1367,13 +1367,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<int[]>();
 
-            BridgeConnector.Socket.On("browserWindow-getMinimumSize-completed", (size) => {
-                BridgeConnector.Socket.Off("browserWindow-getMinimumSize-completed");
+            BridgeConnector.On<int[]>("browserWindow-getMinimumSize-completed", (size) => {
+                BridgeConnector.Off("browserWindow-getMinimumSize-completed");
 
-                taskCompletionSource.SetResult(((JArray)size).ToObject<int[]>());
+                taskCompletionSource.SetResult(size);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetMinimumSize", Id);
+            BridgeConnector.Emit("browserWindowGetMinimumSize", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1385,7 +1385,7 @@ namespace ElectronNET.API
         /// <param name="height"></param>
         public void SetMaximumSize(int width, int height)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetMaximumSize", Id, width, height);
+            BridgeConnector.Emit("browserWindowSetMaximumSize", Id, width, height);
         }
 
         /// <summary>
@@ -1396,13 +1396,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<int[]>();
 
-            BridgeConnector.Socket.On("browserWindow-getMaximumSize-completed", (size) => {
-                BridgeConnector.Socket.Off("browserWindow-getMaximumSize-completed");
+            BridgeConnector.On<int[]>("browserWindow-getMaximumSize-completed", (size) => {
+                BridgeConnector.Off("browserWindow-getMaximumSize-completed");
 
-                taskCompletionSource.SetResult(((JArray)size).ToObject<int[]>());
+                taskCompletionSource.SetResult(size);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetMaximumSize", Id);
+            BridgeConnector.Emit("browserWindowGetMaximumSize", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1413,7 +1413,7 @@ namespace ElectronNET.API
         /// <param name="resizable"></param>
         public void SetResizable(bool resizable)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetResizable", Id, resizable);
+            BridgeConnector.Emit("browserWindowSetResizable", Id, resizable);
         }
 
         /// <summary>
@@ -1424,13 +1424,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isResizable-completed", (resizable) => {
-                BridgeConnector.Socket.Off("browserWindow-isResizable-completed");
+            BridgeConnector.On<bool>("browserWindow-isResizable-completed", (resizable) => {
+                BridgeConnector.Off("browserWindow-isResizable-completed");
 
                 taskCompletionSource.SetResult((bool)resizable);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsResizable", Id);
+            BridgeConnector.Emit("browserWindowIsResizable", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1441,7 +1441,7 @@ namespace ElectronNET.API
         /// <param name="movable"></param>
         public void SetMovable(bool movable)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetMovable", Id, movable);
+            BridgeConnector.Emit("browserWindowSetMovable", Id, movable);
         }
 
         /// <summary>
@@ -1454,13 +1454,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isMovable-completed", (movable) => {
-                BridgeConnector.Socket.Off("browserWindow-isMovable-completed");
+            BridgeConnector.On<bool>("browserWindow-isMovable-completed", (movable) => {
+                BridgeConnector.Off("browserWindow-isMovable-completed");
 
                 taskCompletionSource.SetResult((bool)movable);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsMovable", Id);
+            BridgeConnector.Emit("browserWindowIsMovable", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1471,7 +1471,7 @@ namespace ElectronNET.API
         /// <param name="minimizable"></param>
         public void SetMinimizable(bool minimizable)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetMinimizable", Id, minimizable);
+            BridgeConnector.Emit("browserWindowSetMinimizable", Id, minimizable);
         }
 
         /// <summary>
@@ -1484,13 +1484,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isMinimizable-completed", (minimizable) => {
-                BridgeConnector.Socket.Off("browserWindow-isMinimizable-completed");
+            BridgeConnector.On<bool>("browserWindow-isMinimizable-completed", (minimizable) => {
+                BridgeConnector.Off("browserWindow-isMinimizable-completed");
 
                 taskCompletionSource.SetResult((bool)minimizable);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsMinimizable", Id);
+            BridgeConnector.Emit("browserWindowIsMinimizable", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1501,7 +1501,7 @@ namespace ElectronNET.API
         /// <param name="maximizable"></param>
         public void SetMaximizable(bool maximizable)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetMaximizable", Id, maximizable);
+            BridgeConnector.Emit("browserWindowSetMaximizable", Id, maximizable);
         }
 
         /// <summary>
@@ -1514,13 +1514,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isMaximizable-completed", (maximizable) => {
-                BridgeConnector.Socket.Off("browserWindow-isMaximizable-completed");
+            BridgeConnector.On<bool>("browserWindow-isMaximizable-completed", (maximizable) => {
+                BridgeConnector.Off("browserWindow-isMaximizable-completed");
 
                 taskCompletionSource.SetResult((bool)maximizable);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsMaximizable", Id);
+            BridgeConnector.Emit("browserWindowIsMaximizable", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1531,7 +1531,7 @@ namespace ElectronNET.API
         /// <param name="fullscreenable"></param>
         public void SetFullScreenable(bool fullscreenable)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetFullScreenable", Id, fullscreenable);
+            BridgeConnector.Emit("browserWindowSetFullScreenable", Id, fullscreenable);
         }
 
         /// <summary>
@@ -1542,13 +1542,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isFullScreenable-completed", (fullscreenable) => {
-                BridgeConnector.Socket.Off("browserWindow-isFullScreenable-completed");
+            BridgeConnector.On<bool>("browserWindow-isFullScreenable-completed", (fullscreenable) => {
+                BridgeConnector.Off("browserWindow-isFullScreenable-completed");
 
                 taskCompletionSource.SetResult((bool)fullscreenable);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsFullScreenable", Id);
+            BridgeConnector.Emit("browserWindowIsFullScreenable", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1559,7 +1559,7 @@ namespace ElectronNET.API
         /// <param name="closable"></param>
         public void SetClosable(bool closable)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetClosable", Id, closable);
+            BridgeConnector.Emit("browserWindowSetClosable", Id, closable);
         }
 
         /// <summary>
@@ -1572,13 +1572,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isClosable-completed", (closable) => {
-                BridgeConnector.Socket.Off("browserWindow-isClosable-completed");
+            BridgeConnector.On<bool>("browserWindow-isClosable-completed", (closable) => {
+                BridgeConnector.Off("browserWindow-isClosable-completed");
 
                 taskCompletionSource.SetResult((bool)closable);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsClosable", Id);
+            BridgeConnector.Emit("browserWindowIsClosable", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1591,7 +1591,7 @@ namespace ElectronNET.API
         /// <param name="flag"></param>
         public void SetAlwaysOnTop(bool flag)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetAlwaysOnTop", Id, flag);
+            BridgeConnector.Emit("browserWindowSetAlwaysOnTop", Id, flag);
         }
 
         /// <summary>
@@ -1605,7 +1605,7 @@ namespace ElectronNET.API
         /// See the macOS docs</param>
         public void SetAlwaysOnTop(bool flag, OnTopLevel level)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetAlwaysOnTop", Id, flag, level.GetDescription());
+            BridgeConnector.Emit("browserWindowSetAlwaysOnTop", Id, flag, level.GetDescription());
         }
 
         /// <summary>
@@ -1621,7 +1621,7 @@ namespace ElectronNET.API
         /// The default is 0. Note that Apple discourages setting levels higher than 1 above screen-saver.</param>
         public void SetAlwaysOnTop(bool flag, OnTopLevel level, int relativeLevel)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetAlwaysOnTop", Id, flag, level.GetDescription(), relativeLevel);
+            BridgeConnector.Emit("browserWindowSetAlwaysOnTop", Id, flag, level.GetDescription(), relativeLevel);
         }
 
         /// <summary>
@@ -1632,13 +1632,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isAlwaysOnTop-completed", (isAlwaysOnTop) => {
-                BridgeConnector.Socket.Off("browserWindow-isAlwaysOnTop-completed");
+            BridgeConnector.On<bool>("browserWindow-isAlwaysOnTop-completed", (isAlwaysOnTop) => {
+                BridgeConnector.Off("browserWindow-isAlwaysOnTop-completed");
 
                 taskCompletionSource.SetResult((bool)isAlwaysOnTop);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsAlwaysOnTop", Id);
+            BridgeConnector.Emit("browserWindowIsAlwaysOnTop", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1648,7 +1648,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Center()
         {
-            BridgeConnector.Socket.Emit("browserWindowCenter", Id);
+            BridgeConnector.Emit("browserWindowCenter", Id);
         }
 
         /// <summary>
@@ -1665,7 +1665,7 @@ namespace ElectronNET.API
                 x = x - 7;
             }
 
-            BridgeConnector.Socket.Emit("browserWindowSetPosition", Id, x, y);
+            BridgeConnector.Emit("browserWindowSetPosition", Id, x, y);
         }
 
         /// <summary>
@@ -1683,7 +1683,7 @@ namespace ElectronNET.API
                 x = x - 7;
             }
 
-            BridgeConnector.Socket.Emit("browserWindowSetPosition", Id, x, y, animate);
+            BridgeConnector.Emit("browserWindowSetPosition", Id, x, y, animate);
         }
 
         private bool isWindows10()
@@ -1699,13 +1699,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<int[]>();
 
-            BridgeConnector.Socket.On("browserWindow-getPosition-completed", (position) => {
-                BridgeConnector.Socket.Off("browserWindow-getPosition-completed");
+            BridgeConnector.On<int[]>("browserWindow-getPosition-completed", (position) => {
+                BridgeConnector.Off("browserWindow-getPosition-completed");
 
-                taskCompletionSource.SetResult(((JArray)position).ToObject<int[]>());
+                taskCompletionSource.SetResult(position);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetPosition", Id);
+            BridgeConnector.Emit("browserWindowGetPosition", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1716,7 +1716,7 @@ namespace ElectronNET.API
         /// <param name="title"></param>
         public void SetTitle(string title)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetTitle", Id, title);
+            BridgeConnector.Emit("browserWindowSetTitle", Id, title);
         }
 
         /// <summary>
@@ -1729,13 +1729,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("browserWindow-getTitle-completed", (title) => {
-                BridgeConnector.Socket.Off("browserWindow-getTitle-completed");
+            BridgeConnector.On<string>("browserWindow-getTitle-completed", (title) => {
+                BridgeConnector.Off("browserWindow-getTitle-completed");
 
-                taskCompletionSource.SetResult(title.ToString());
+                taskCompletionSource.SetResult(title);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetTitle", Id);
+            BridgeConnector.Emit("browserWindowGetTitle", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1748,7 +1748,7 @@ namespace ElectronNET.API
         /// <param name="offsetY"></param>
         public void SetSheetOffset(float offsetY)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetSheetOffset", Id, offsetY);
+            BridgeConnector.Emit("browserWindowSetSheetOffset", Id, offsetY);
         }
 
         /// <summary>
@@ -1760,7 +1760,7 @@ namespace ElectronNET.API
         /// <param name="offsetX"></param>
         public void SetSheetOffset(float offsetY, float offsetX)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetSheetOffset", Id, offsetY, offsetX);
+            BridgeConnector.Emit("browserWindowSetSheetOffset", Id, offsetY, offsetX);
         }
 
         /// <summary>
@@ -1769,7 +1769,7 @@ namespace ElectronNET.API
         /// <param name="flag"></param>
         public void FlashFrame(bool flag)
         {
-            BridgeConnector.Socket.Emit("browserWindowFlashFrame", Id, flag);
+            BridgeConnector.Emit("browserWindowFlashFrame", Id, flag);
         }
 
         /// <summary>
@@ -1778,7 +1778,7 @@ namespace ElectronNET.API
         /// <param name="skip"></param>
         public void SetSkipTaskbar(bool skip)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetSkipTaskbar", Id, skip);
+            BridgeConnector.Emit("browserWindowSetSkipTaskbar", Id, skip);
         }
 
         /// <summary>
@@ -1787,7 +1787,7 @@ namespace ElectronNET.API
         /// <param name="flag"></param>
         public void SetKiosk(bool flag)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetKiosk", Id, flag);
+            BridgeConnector.Emit("browserWindowSetKiosk", Id, flag);
         }
 
         /// <summary>
@@ -1798,13 +1798,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isKiosk-completed", (isKiosk) => {
-                BridgeConnector.Socket.Off("browserWindow-isKiosk-completed");
+            BridgeConnector.On<bool>("browserWindow-isKiosk-completed", (isKiosk) => {
+                BridgeConnector.Off("browserWindow-isKiosk-completed");
 
                 taskCompletionSource.SetResult((bool)isKiosk);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsKiosk", Id);
+            BridgeConnector.Emit("browserWindowIsKiosk", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1817,13 +1817,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("browserWindow-getNativeWindowHandle-completed", (nativeWindowHandle) =>
+            BridgeConnector.On<string>("browserWindow-getNativeWindowHandle-completed", (nativeWindowHandle) =>
             {
-                BridgeConnector.Socket.Off("browserWindow-getNativeWindowHandle-completed");
-                taskCompletionSource.SetResult(nativeWindowHandle.ToString());
+                BridgeConnector.Off("browserWindow-getNativeWindowHandle-completed");
+                taskCompletionSource.SetResult(nativeWindowHandle);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetNativeWindowHandle", Id);
+            BridgeConnector.Emit("browserWindowGetNativeWindowHandle", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1835,7 +1835,7 @@ namespace ElectronNET.API
         /// <param name="filename"></param>
         public void SetRepresentedFilename(string filename)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetRepresentedFilename", Id, filename);
+            BridgeConnector.Emit("browserWindowSetRepresentedFilename", Id, filename);
         }
 
         /// <summary>
@@ -1846,13 +1846,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("browserWindow-getRepresentedFilename-completed", (pathname) => {
-                BridgeConnector.Socket.Off("browserWindow-getRepresentedFilename-completed");
+            BridgeConnector.On<string>("browserWindow-getRepresentedFilename-completed", (pathname) => {
+                BridgeConnector.Off("browserWindow-getRepresentedFilename-completed");
 
-                taskCompletionSource.SetResult(pathname.ToString());
+                taskCompletionSource.SetResult(pathname);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetRepresentedFilename", Id);
+            BridgeConnector.Emit("browserWindowGetRepresentedFilename", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1864,7 +1864,7 @@ namespace ElectronNET.API
         /// <param name="edited"></param>
         public void SetDocumentEdited(bool edited)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetDocumentEdited", Id, edited);
+            BridgeConnector.Emit("browserWindowSetDocumentEdited", Id, edited);
         }
 
         /// <summary>
@@ -1875,13 +1875,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isDocumentEdited-completed", (edited) => {
-                BridgeConnector.Socket.Off("browserWindow-isDocumentEdited-completed");
+            BridgeConnector.On<bool>("browserWindow-isDocumentEdited-completed", (edited) => {
+                BridgeConnector.Off("browserWindow-isDocumentEdited-completed");
 
                 taskCompletionSource.SetResult((bool)edited);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsDocumentEdited", Id);
+            BridgeConnector.Emit("browserWindowIsDocumentEdited", Id);
 
             return taskCompletionSource.Task;
         }
@@ -1891,7 +1891,7 @@ namespace ElectronNET.API
         /// </summary>
         public void FocusOnWebView()
         {
-            BridgeConnector.Socket.Emit("browserWindowFocusOnWebView", Id);
+            BridgeConnector.Emit("browserWindowFocusOnWebView", Id);
         }
 
         /// <summary>
@@ -1899,7 +1899,7 @@ namespace ElectronNET.API
         /// </summary>
         public void BlurWebView()
         {
-            BridgeConnector.Socket.Emit("browserWindowBlurWebView", Id);
+            BridgeConnector.Emit("browserWindowBlurWebView", Id);
         }
 
         /// <summary>
@@ -1909,7 +1909,7 @@ namespace ElectronNET.API
         /// <param name="url"></param>
         public void LoadURL(string url)
         {
-            BridgeConnector.Socket.Emit("browserWindowLoadURL", Id, url);
+            BridgeConnector.Emit("browserWindowLoadURL", Id, url);
         }
 
         /// <summary>
@@ -1920,7 +1920,7 @@ namespace ElectronNET.API
         /// <param name="options"></param>
         public void LoadURL(string url, LoadURLOptions options)
         {
-            BridgeConnector.Socket.Emit("browserWindowLoadURL", Id, url, JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("browserWindowLoadURL", Id, url, JObject.FromObject(options, _jsonSerializer));
         }
 
         /// <summary>
@@ -1928,7 +1928,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Reload()
         {
-            BridgeConnector.Socket.Emit("browserWindowReload", Id);
+            BridgeConnector.Emit("browserWindowReload", Id);
         }
 
         /// <summary>
@@ -1948,12 +1948,12 @@ namespace ElectronNET.API
         public void SetMenu(MenuItem[] menuItems)
         {
             menuItems.AddMenuItemsId();
-            BridgeConnector.Socket.Emit("browserWindowSetMenu", Id, JArray.FromObject(menuItems, _jsonSerializer));
+            BridgeConnector.Emit("browserWindowSetMenu", Id, JArray.FromObject(menuItems, _jsonSerializer));
             _items.AddRange(menuItems);
 
-            BridgeConnector.Socket.Off("windowMenuItemClicked");
-            BridgeConnector.Socket.On("windowMenuItemClicked", (id) => {
-                MenuItem menuItem = _items.GetMenuItem(id.ToString());
+            BridgeConnector.Off("windowMenuItemClicked");
+            BridgeConnector.On<string>("windowMenuItemClicked", (id) => {
+                MenuItem menuItem = _items.GetMenuItem(id);
                 menuItem?.Click();
             });
         }
@@ -1963,7 +1963,7 @@ namespace ElectronNET.API
         /// </summary>
         public void RemoveMenu()
         {
-            BridgeConnector.Socket.Emit("browserWindowRemoveMenu", Id);
+            BridgeConnector.Emit("browserWindowRemoveMenu", Id);
         }
 
         /// <summary>
@@ -1979,7 +1979,7 @@ namespace ElectronNET.API
         /// <param name="progress"></param>
         public void SetProgressBar(double progress)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetProgressBar", Id, progress);
+            BridgeConnector.Emit("browserWindowSetProgressBar", Id, progress);
         }
 
         /// <summary>
@@ -1996,7 +1996,7 @@ namespace ElectronNET.API
         /// <param name="progressBarOptions"></param>
         public void SetProgressBar(double progress, ProgressBarOptions progressBarOptions)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetProgressBar", Id, progress, JObject.FromObject(progressBarOptions, _jsonSerializer));
+            BridgeConnector.Emit("browserWindowSetProgressBar", Id, progress, JObject.FromObject(progressBarOptions, _jsonSerializer));
         }
 
         /// <summary>
@@ -2005,7 +2005,7 @@ namespace ElectronNET.API
         /// <param name="hasShadow"></param>
         public void SetHasShadow(bool hasShadow)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetHasShadow", Id, hasShadow);
+            BridgeConnector.Emit("browserWindowSetHasShadow", Id, hasShadow);
         }
 
         /// <summary>
@@ -2018,13 +2018,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-hasShadow-completed", (hasShadow) => {
-                BridgeConnector.Socket.Off("browserWindow-hasShadow-completed");
+            BridgeConnector.On<bool>("browserWindow-hasShadow-completed", (hasShadow) => {
+                BridgeConnector.Off("browserWindow-hasShadow-completed");
 
                 taskCompletionSource.SetResult((bool)hasShadow);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowHasShadow", Id);
+            BridgeConnector.Emit("browserWindowHasShadow", Id);
 
             return taskCompletionSource.Task;
         }
@@ -2054,20 +2054,20 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindowSetThumbarButtons-completed", (success) => {
-                BridgeConnector.Socket.Off("browserWindowSetThumbarButtons-completed");
+            BridgeConnector.On<bool>("browserWindowSetThumbarButtons-completed", (success) => {
+                BridgeConnector.Off("browserWindowSetThumbarButtons-completed");
 
                 taskCompletionSource.SetResult((bool)success);
             });
 
             thumbarButtons.AddThumbarButtonsId();
-            BridgeConnector.Socket.Emit("browserWindowSetThumbarButtons", Id, JArray.FromObject(thumbarButtons, _jsonSerializer));
+            BridgeConnector.Emit("browserWindowSetThumbarButtons", Id, JArray.FromObject(thumbarButtons, _jsonSerializer));
             _thumbarButtons.Clear();
             _thumbarButtons.AddRange(thumbarButtons);
 
-            BridgeConnector.Socket.Off("thumbarButtonClicked");
-            BridgeConnector.Socket.On("thumbarButtonClicked", (id) => {
-                ThumbarButton thumbarButton = _thumbarButtons.GetThumbarButton(id.ToString());
+            BridgeConnector.Off("thumbarButtonClicked");
+            BridgeConnector.On<string>("thumbarButtonClicked", (id) => {
+                ThumbarButton thumbarButton = _thumbarButtons.GetThumbarButton(id);
                 thumbarButton?.Click();
             });
 
@@ -2082,7 +2082,7 @@ namespace ElectronNET.API
         /// <param name="rectangle"></param>
         public void SetThumbnailClip(Rectangle rectangle)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetThumbnailClip", Id, rectangle);
+            BridgeConnector.Emit("browserWindowSetThumbnailClip", Id, rectangle);
         }
 
         /// <summary>
@@ -2091,7 +2091,7 @@ namespace ElectronNET.API
         /// <param name="tooltip"></param>
         public void SetThumbnailToolTip(string tooltip)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetThumbnailToolTip", Id, tooltip);
+            BridgeConnector.Emit("browserWindowSetThumbnailToolTip", Id, tooltip);
         }
 
         /// <summary>
@@ -2103,7 +2103,7 @@ namespace ElectronNET.API
         /// <param name="options"></param>
         public void SetAppDetails(AppDetailsOptions options)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetAppDetails", Id, JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("browserWindowSetAppDetails", Id, JObject.FromObject(options, _jsonSerializer));
         }
 
         /// <summary>
@@ -2111,7 +2111,7 @@ namespace ElectronNET.API
         /// </summary>
         public void ShowDefinitionForSelection()
         {
-            BridgeConnector.Socket.Emit("browserWindowShowDefinitionForSelection", Id);
+            BridgeConnector.Emit("browserWindowShowDefinitionForSelection", Id);
         }
 
         /// <summary>
@@ -2123,7 +2123,7 @@ namespace ElectronNET.API
         /// <param name="hide"></param>
         public void SetAutoHideMenuBar(bool hide)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetAutoHideMenuBar", Id, hide);
+            BridgeConnector.Emit("browserWindowSetAutoHideMenuBar", Id, hide);
         }
 
         /// <summary>
@@ -2134,13 +2134,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isMenuBarAutoHide-completed", (isMenuBarAutoHide) => {
-                BridgeConnector.Socket.Off("browserWindow-isMenuBarAutoHide-completed");
+            BridgeConnector.On<bool>("browserWindow-isMenuBarAutoHide-completed", (isMenuBarAutoHide) => {
+                BridgeConnector.Off("browserWindow-isMenuBarAutoHide-completed");
 
                 taskCompletionSource.SetResult((bool)isMenuBarAutoHide);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsMenuBarAutoHide", Id);
+            BridgeConnector.Emit("browserWindowIsMenuBarAutoHide", Id);
 
             return taskCompletionSource.Task;
         }
@@ -2152,7 +2152,7 @@ namespace ElectronNET.API
         /// <param name="visible"></param>
         public void SetMenuBarVisibility(bool visible)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetMenuBarVisibility", Id, visible);
+            BridgeConnector.Emit("browserWindowSetMenuBarVisibility", Id, visible);
         }
 
         /// <summary>
@@ -2163,13 +2163,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isMenuBarVisible-completed", (isMenuBarVisible) => {
-                BridgeConnector.Socket.Off("browserWindow-isMenuBarVisible-completed");
+            BridgeConnector.On<bool>("browserWindow-isMenuBarVisible-completed", (isMenuBarVisible) => {
+                BridgeConnector.Off("browserWindow-isMenuBarVisible-completed");
 
                 taskCompletionSource.SetResult((bool)isMenuBarVisible);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsMenuBarVisible", Id);
+            BridgeConnector.Emit("browserWindowIsMenuBarVisible", Id);
 
             return taskCompletionSource.Task;
         }
@@ -2182,7 +2182,7 @@ namespace ElectronNET.API
         /// <param name="visible"></param>
         public void SetVisibleOnAllWorkspaces(bool visible)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetVisibleOnAllWorkspaces", Id, visible);
+            BridgeConnector.Emit("browserWindowSetVisibleOnAllWorkspaces", Id, visible);
         }
 
         /// <summary>
@@ -2195,13 +2195,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("browserWindow-isVisibleOnAllWorkspaces-completed", (isVisibleOnAllWorkspaces) => {
-                BridgeConnector.Socket.Off("browserWindow-isVisibleOnAllWorkspaces-completed");
+            BridgeConnector.On<bool>("browserWindow-isVisibleOnAllWorkspaces-completed", (isVisibleOnAllWorkspaces) => {
+                BridgeConnector.Off("browserWindow-isVisibleOnAllWorkspaces-completed");
 
                 taskCompletionSource.SetResult((bool)isVisibleOnAllWorkspaces);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowIsVisibleOnAllWorkspaces", Id);
+            BridgeConnector.Emit("browserWindowIsVisibleOnAllWorkspaces", Id);
 
             return taskCompletionSource.Task;
         }
@@ -2215,7 +2215,7 @@ namespace ElectronNET.API
         /// <param name="ignore"></param>
         public void SetIgnoreMouseEvents(bool ignore)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetIgnoreMouseEvents", Id, ignore);
+            BridgeConnector.Emit("browserWindowSetIgnoreMouseEvents", Id, ignore);
         }
 
         /// <summary>
@@ -2227,7 +2227,7 @@ namespace ElectronNET.API
         /// <param name="enable"></param>
         public void SetContentProtection(bool enable)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetContentProtection", Id, enable);
+            BridgeConnector.Emit("browserWindowSetContentProtection", Id, enable);
         }
 
         /// <summary>
@@ -2236,7 +2236,7 @@ namespace ElectronNET.API
         /// <param name="focusable"></param>
         public void SetFocusable(bool focusable)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetFocusable", Id, focusable);
+            BridgeConnector.Emit("browserWindowSetFocusable", Id, focusable);
         }
 
         /// <summary>
@@ -2246,7 +2246,7 @@ namespace ElectronNET.API
         /// <param name="parent"></param>
         public void SetParentWindow(BrowserWindow parent)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetParentWindow", Id, JObject.FromObject(parent, _jsonSerializer));
+            BridgeConnector.Emit("browserWindowSetParentWindow", Id, JObject.FromObject(parent, _jsonSerializer));
         }
 
         /// <summary>
@@ -2257,15 +2257,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<BrowserWindow>();
 
-            BridgeConnector.Socket.On("browserWindow-getParentWindow-completed", (id) => {
-                BridgeConnector.Socket.Off("browserWindow-getParentWindow-completed");
-                var browserWindowId = int.Parse(id.ToString());
-                var browserWindow = Electron.WindowManager.BrowserWindows.ToList().Single(x => x.Id == browserWindowId);
-
+            BridgeConnector.On<int>("browserWindow-getParentWindow-completed", (id) => {
+                BridgeConnector.Off("browserWindow-getParentWindow-completed");
+                var browserWindow = Electron.WindowManager.BrowserWindows.ToList().Single(x => x.Id == id);
                 taskCompletionSource.SetResult(browserWindow);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetParentWindow", Id);
+            BridgeConnector.Emit("browserWindowGetParentWindow", Id);
 
             return taskCompletionSource.Task;
         }
@@ -2278,22 +2276,19 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<List<BrowserWindow>>();
 
-            BridgeConnector.Socket.On("browserWindow-getChildWindows-completed", (ids) => {
-                BridgeConnector.Socket.Off("browserWindow-getChildWindows-completed");
-                var browserWindowIds = ((JArray)ids).ToObject<int[]>();
+            BridgeConnector.On<int[]>("browserWindow-getChildWindows-completed", (ids) => {
+                BridgeConnector.Off("browserWindow-getChildWindows-completed");
                 var browserWindows = new List<BrowserWindow>();
-
-                browserWindowIds.ToList().ForEach(id =>
+                ids.ToList().ForEach(id =>
                 {
                     var browserWindow = Electron.WindowManager.BrowserWindows.ToList().Single(x => x.Id == id);
                     browserWindows.Add(browserWindow);
                 });
 
-
                 taskCompletionSource.SetResult(browserWindows);
             });
 
-            BridgeConnector.Socket.Emit("browserWindowGetChildWindows", Id);
+            BridgeConnector.Emit("browserWindowGetChildWindows", Id);
 
             return taskCompletionSource.Task;
         }
@@ -2304,7 +2299,7 @@ namespace ElectronNET.API
         /// <param name="autoHide"></param>
         public void SetAutoHideCursor(bool autoHide)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetAutoHideCursor", Id, autoHide);
+            BridgeConnector.Emit("browserWindowSetAutoHideCursor", Id, autoHide);
         }
 
         /// <summary>
@@ -2316,7 +2311,7 @@ namespace ElectronNET.API
         /// See the macOS documentation for more details.</param>
         public void SetVibrancy(Vibrancy type)
         {
-            BridgeConnector.Socket.Emit("browserWindowSetVibrancy", Id, type.GetDescription());
+            BridgeConnector.Emit("browserWindowSetVibrancy", Id, type.GetDescription());
         }
 
         /// <summary>
@@ -2332,7 +2327,7 @@ namespace ElectronNET.API
         /// <param name="browserView"></param>
         public void SetBrowserView(BrowserView browserView)
         {
-            BridgeConnector.Socket.Emit("browserWindow-setBrowserView", Id, browserView.Id);
+            BridgeConnector.Emit("browserWindow-setBrowserView", Id, browserView.Id);
         }
 
         private JsonSerializer _jsonSerializer = new JsonSerializer()
diff --git a/ElectronNET.API/Clipboard.cs b/ElectronNET.API/Clipboard.cs
index e753537..68d1876 100644
--- a/ElectronNET.API/Clipboard.cs
+++ b/ElectronNET.API/Clipboard.cs
@@ -44,14 +44,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("clipboard-readText-Completed", (text) =>
+            BridgeConnector.On<string>("clipboard-readText-Completed", (text) =>
             {
-                BridgeConnector.Socket.Off("clipboard-readText-Completed");
+                BridgeConnector.Off("clipboard-readText-Completed");
 
-                taskCompletionSource.SetResult(text.ToString());
+                taskCompletionSource.SetResult(text);
             });
 
-            BridgeConnector.Socket.Emit("clipboard-readText", type);
+            BridgeConnector.Emit("clipboard-readText", type);
 
             return taskCompletionSource.Task;
         }
@@ -63,7 +63,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>
@@ -75,14 +75,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("clipboard-readHTML-Completed", (text) =>
+            BridgeConnector.On<string>("clipboard-readHTML-Completed", (text) =>
             {
-                BridgeConnector.Socket.Off("clipboard-readHTML-Completed");
+                BridgeConnector.Off("clipboard-readHTML-Completed");
 
-                taskCompletionSource.SetResult(text.ToString());
+                taskCompletionSource.SetResult(text);
             });
 
-            BridgeConnector.Socket.Emit("clipboard-readHTML", type);
+            BridgeConnector.Emit("clipboard-readHTML", type);
 
             return taskCompletionSource.Task;
         }
@@ -94,7 +94,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>
@@ -106,14 +106,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("clipboard-readRTF-Completed", (text) =>
+            BridgeConnector.On<string>("clipboard-readRTF-Completed", (text) =>
             {
-                BridgeConnector.Socket.Off("clipboard-readRTF-Completed");
+                BridgeConnector.Off("clipboard-readRTF-Completed");
 
-                taskCompletionSource.SetResult(text.ToString());
+                taskCompletionSource.SetResult(text);
             });
 
-            BridgeConnector.Socket.Emit("clipboard-readRTF", type);
+            BridgeConnector.Emit("clipboard-readRTF", type);
 
             return taskCompletionSource.Task;
         }
@@ -125,7 +125,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>
@@ -138,14 +138,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<ReadBookmark>();
 
-            BridgeConnector.Socket.On("clipboard-readBookmark-Completed", (bookmark) =>
+            BridgeConnector.On<ReadBookmark>("clipboard-readBookmark-Completed", (bookmark) =>
             {
-                BridgeConnector.Socket.Off("clipboard-readBookmark-Completed");
+                BridgeConnector.Off("clipboard-readBookmark-Completed");
 
-                taskCompletionSource.SetResult(((JObject)bookmark).ToObject<ReadBookmark>());
+                taskCompletionSource.SetResult(bookmark);
             });
 
-            BridgeConnector.Socket.Emit("clipboard-readBookmark");
+            BridgeConnector.Emit("clipboard-readBookmark");
 
             return taskCompletionSource.Task;
         }
@@ -162,7 +162,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>
@@ -175,14 +175,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("clipboard-readFindText-Completed", (text) =>
+            BridgeConnector.On<string>("clipboard-readFindText-Completed", (text) =>
             {
-                BridgeConnector.Socket.Off("clipboard-readFindText-Completed");
+                BridgeConnector.Off("clipboard-readFindText-Completed");
 
-                taskCompletionSource.SetResult(text.ToString());
+                taskCompletionSource.SetResult(text);
             });
 
-            BridgeConnector.Socket.Emit("clipboard-readFindText");
+            BridgeConnector.Emit("clipboard-readFindText");
 
             return taskCompletionSource.Task;
         }
@@ -194,7 +194,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 +203,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>
@@ -215,14 +215,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string[]>();
 
-            BridgeConnector.Socket.On("clipboard-availableFormats-Completed", (formats) =>
+            BridgeConnector.On<string[]>("clipboard-availableFormats-Completed", (formats) =>
             {
-                BridgeConnector.Socket.Off("clipboard-availableFormats-Completed");
+                BridgeConnector.Off("clipboard-availableFormats-Completed");
 
-                taskCompletionSource.SetResult(((JArray)formats).ToObject<string[]>());
+                taskCompletionSource.SetResult(formats);
             });
 
-            BridgeConnector.Socket.Emit("clipboard-availableFormats", type);
+            BridgeConnector.Emit("clipboard-availableFormats", type);
 
             return taskCompletionSource.Task;
         }
@@ -234,7 +234,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", JObject.FromObject(data, _jsonSerializer), type);
         }
 
         /// <summary>
@@ -246,17 +246,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<NativeImage>();
 
-            BridgeConnector.Socket.On("clipboard-readImage-Completed", (image) =>
+            BridgeConnector.On<NativeImage>("clipboard-readImage-Completed", (image) =>
             {
-                BridgeConnector.Socket.Off("clipboard-readImage-Completed");
+                BridgeConnector.Off("clipboard-readImage-Completed");
 
-                var nativeImage = ((JObject)image).ToObject<NativeImage>();
-
-                taskCompletionSource.SetResult(nativeImage);
-                
+                taskCompletionSource.SetResult(image);                
             });
 
-            BridgeConnector.Socket.Emit("clipboard-readImage", type);
+            BridgeConnector.Emit("clipboard-readImage", type);
             
             return taskCompletionSource.Task;
         }
@@ -268,7 +265,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()
diff --git a/ElectronNET.API/CommandLine.cs b/ElectronNET.API/CommandLine.cs
index 63466b4..6b09058 100644
--- a/ElectronNET.API/CommandLine.cs
+++ b/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>
@@ -73,13 +73,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appCommandLineHasSwitchCompleted", (result) =>
+                BridgeConnector.On<bool>("appCommandLineHasSwitchCompleted", (result) =>
                 {
-                    BridgeConnector.Socket.Off("appCommandLineHasSwitchCompleted");
+                    BridgeConnector.Off("appCommandLineHasSwitchCompleted");
                     taskCompletionSource.SetResult((bool)result);
                 });
 
-                BridgeConnector.Socket.Emit("appCommandLineHasSwitch", switchName);
+                BridgeConnector.Emit("appCommandLineHasSwitch", switchName);
 
                 return await taskCompletionSource.Task.ConfigureAwait(false);
             }
@@ -101,13 +101,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("appCommandLineGetSwitchValueCompleted", (result) =>
+                BridgeConnector.On<string>("appCommandLineGetSwitchValueCompleted", (result) =>
                 {
-                    BridgeConnector.Socket.Off("appCommandLineGetSwitchValueCompleted");
-                    taskCompletionSource.SetResult((string)result);
+                    BridgeConnector.Off("appCommandLineGetSwitchValueCompleted");
+                    taskCompletionSource.SetResult(result);
                 });
 
-                BridgeConnector.Socket.Emit("appCommandLineGetSwitchValue", switchName);
+                BridgeConnector.Emit("appCommandLineGetSwitchValue", switchName);
 
                 return await taskCompletionSource.Task.ConfigureAwait(false);
             }
diff --git a/ElectronNET.API/Cookies.cs b/ElectronNET.API/Cookies.cs
index 98be3d4..2d8ca65 100644
--- a/ElectronNET.API/Cookies.cs
+++ b/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);
             }
         }
 
@@ -68,15 +65,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<Cookie[]>();
             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, JObject.FromObject(filter, _jsonSerializer), guid);
 
             return taskCompletionSource.Task;
         }
@@ -91,13 +86,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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, JObject.FromObject(details, _jsonSerializer), guid);
 
             return taskCompletionSource.Task;
         }
@@ -113,13 +108,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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;
         }
@@ -133,13 +128,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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;
         }
diff --git a/ElectronNET.API/Dialog.cs b/ElectronNET.API/Dialog.cs
index 7b626b4..9df9e4a 100644
--- a/ElectronNET.API/Dialog.cs
+++ b/ElectronNET.API/Dialog.cs
@@ -51,13 +51,12 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string[]>();
             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));
                 }
@@ -65,7 +64,7 @@ namespace ElectronNET.API
             });
 
 
-            BridgeConnector.Socket.Emit("showOpenDialog",
+            BridgeConnector.Emit("showOpenDialog",
             JObject.FromObject(browserWindow, _jsonSerializer),
             JObject.FromObject(options, _jsonSerializer), guid);
 
@@ -83,14 +82,14 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             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",
+            BridgeConnector.Emit("showSaveDialog",
             JObject.FromObject(browserWindow, _jsonSerializer),
             JObject.FromObject(options, _jsonSerializer),
             guid);
@@ -152,26 +151,24 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<MessageBoxResult>();
             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", JObject.FromObject(messageBoxOptions, _jsonSerializer), guid);
             } else
             {
-                BridgeConnector.Socket.Emit("showMessageBox", 
+                BridgeConnector.Emit("showMessageBox", 
                     JObject.FromObject(browserWindow, _jsonSerializer),
                     JObject.FromObject(messageBoxOptions, _jsonSerializer),
                     guid);
@@ -192,7 +189,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>
@@ -220,13 +217,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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",
+            BridgeConnector.Emit("showCertificateTrustDialog",
                 JObject.FromObject(browserWindow, _jsonSerializer),
                 JObject.FromObject(options, _jsonSerializer),
                 guid);
diff --git a/ElectronNET.API/Dock.cs b/ElectronNET.API/Dock.cs
index 0327684..3602527 100644
--- a/ElectronNET.API/Dock.cs
+++ b/ElectronNET.API/Dock.cs
@@ -57,13 +57,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<int>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("dock-bounce-completed", (id) =>
+                BridgeConnector.On<int>("dock-bounce-completed", (id) =>
                 {
-                    BridgeConnector.Socket.Off("dock-bounce-completed");
-                    taskCompletionSource.SetResult((int) id);
+                    BridgeConnector.Off("dock-bounce-completed");
+                    taskCompletionSource.SetResult(id);
                 });
 
-                BridgeConnector.Socket.Emit("dock-bounce", type.GetDescription());
+                BridgeConnector.Emit("dock-bounce", type.GetDescription());
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -76,7 +76,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 +85,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 +94,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>
@@ -109,13 +109,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("dock-getBadge-completed", (text) =>
+                BridgeConnector.On<string>("dock-getBadge-completed", (text) =>
                 {
-                    BridgeConnector.Socket.Off("dock-getBadge-completed");
-                    taskCompletionSource.SetResult((string) text);
+                    BridgeConnector.Off("dock-getBadge-completed");
+                    taskCompletionSource.SetResult(text);
                 });
 
-                BridgeConnector.Socket.Emit("dock-getBadge");
+                BridgeConnector.Emit("dock-getBadge");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -127,7 +127,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Hide()
         {
-            BridgeConnector.Socket.Emit("dock-hide");
+            BridgeConnector.Emit("dock-hide");
         }
 
         /// <summary>
@@ -135,7 +135,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Show()
         {
-            BridgeConnector.Socket.Emit("dock-show");
+            BridgeConnector.Emit("dock-show");
         }
 
         /// <summary>
@@ -151,13 +151,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<bool>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("dock-isVisible-completed", (isVisible) =>
+                BridgeConnector.On<bool>("dock-isVisible-completed", (isVisible) =>
                 {
-                    BridgeConnector.Socket.Off("dock-isVisible-completed");
+                    BridgeConnector.Off("dock-isVisible-completed");
                     taskCompletionSource.SetResult((bool) isVisible);
                 });
 
-                BridgeConnector.Socket.Emit("dock-isVisible");
+                BridgeConnector.Emit("dock-isVisible");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -179,12 +179,12 @@ 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();
             });
            
@@ -201,13 +201,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<Menu>();
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.On("dock-getMenu-completed", (menu) =>
+                BridgeConnector.On<Menu>("dock-getMenu-completed", (menu) =>
                 {
-                    BridgeConnector.Socket.Off("dock-getMenu-completed");
-                    taskCompletionSource.SetResult(((JObject)menu).ToObject<Menu>());
+                    BridgeConnector.Off("dock-getMenu-completed");
+                    taskCompletionSource.SetResult(menu);
                 });
 
-                BridgeConnector.Socket.Emit("dock-getMenu");
+                BridgeConnector.Emit("dock-getMenu");
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -220,7 +220,7 @@ 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()
diff --git a/ElectronNET.API/ElectronNET.API.csproj b/ElectronNET.API/ElectronNET.API.csproj
index d6beb0b..37160d1 100644
--- a/ElectronNET.API/ElectronNET.API.csproj
+++ b/ElectronNET.API/ElectronNET.API.csproj
@@ -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.2.4" />
+    <PackageReference Include="SocketIOClient.Newtonsoft.Json" Version="2.2.1" />
+    <PackageReference Include="System.Drawing.Common" Version="5.0.2" />
   </ItemGroup>
 
 </Project>
diff --git a/ElectronNET.API/Entities/JumpListSettings.cs b/ElectronNET.API/Entities/JumpListSettings.cs
index 82184ed..150d0b7 100644
--- a/ElectronNET.API/Entities/JumpListSettings.cs
+++ b/ElectronNET.API/Entities/JumpListSettings.cs
@@ -1,8 +1,5 @@
 namespace ElectronNET.API.Entities
 {
-    /// <summary>
-    /// 
-    /// </summary>
     public class JumpListSettings
     {
         /// <summary>
diff --git a/ElectronNET.API/Entities/MessageBoxResult.cs b/ElectronNET.API/Entities/MessageBoxResult.cs
index 835c292..8910dff 100644
--- a/ElectronNET.API/Entities/MessageBoxResult.cs
+++ b/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>
diff --git a/ElectronNET.API/Entities/SecondInstanceResponse.cs b/ElectronNET.API/Entities/SecondInstanceResponse.cs
new file mode 100644
index 0000000..de3e2ec
--- /dev/null
+++ b/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;}
+    }
+}
\ No newline at end of file
diff --git a/ElectronNET.API/Events.cs b/ElectronNET.API/Events.cs
index bbbee34..6c01cdc 100644
--- a/ElectronNET.API/Events.cs
+++ b/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);
         }
-
     }
 }
diff --git a/ElectronNET.API/GlobalShortcut.cs b/ElectronNET.API/GlobalShortcut.cs
index d2867ec..2109e29 100644
--- a/ElectronNET.API/GlobalShortcut.cs
+++ b/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);
             }
         }
 
@@ -72,14 +72,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("globalShortcut-isRegisteredCompleted", (isRegistered) =>
+            BridgeConnector.On<bool>("globalShortcut-isRegisteredCompleted", (isRegistered) =>
             {
-                BridgeConnector.Socket.Off("globalShortcut-isRegisteredCompleted");
+                BridgeConnector.Off("globalShortcut-isRegisteredCompleted");
 
-                taskCompletionSource.SetResult((bool)isRegistered);
+                taskCompletionSource.SetResult(isRegistered);
             });
 
-            BridgeConnector.Socket.Emit("globalShortcut-isRegistered", accelerator);
+            BridgeConnector.Emit("globalShortcut-isRegistered", accelerator);
 
             return taskCompletionSource.Task;
         }
@@ -90,7 +90,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 +99,7 @@ namespace ElectronNET.API
         public void UnregisterAll()
         {
             _shortcuts.Clear();
-            BridgeConnector.Socket.Emit("globalShortcut-unregisterAll");
+            BridgeConnector.Emit("globalShortcut-unregisterAll");
         }
     }
 }
\ No newline at end of file
diff --git a/ElectronNET.API/HostHook.cs b/ElectronNET.API/HostHook.cs
index 3760625..8b98258 100644
--- a/ElectronNET.API/HostHook.cs
+++ b/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>
@@ -68,52 +68,21 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<T>();
             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;
         }
diff --git a/ElectronNET.API/IpcMain.cs b/ElectronNET.API/IpcMain.cs
index 3e950c1..1508078 100644
--- a/ElectronNET.API/IpcMain.cs
+++ b/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,11 +199,11 @@ 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);
             }
         }
 
diff --git a/ElectronNET.API/Menu.cs b/ElectronNET.API/Menu.cs
index 8397a10..aa98613 100644
--- a/ElectronNET.API/Menu.cs
+++ b/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()
diff --git a/ElectronNET.API/MenuResponse.cs b/ElectronNET.API/MenuResponse.cs
new file mode 100644
index 0000000..876a363
--- /dev/null
+++ b/ElectronNET.API/MenuResponse.cs
@@ -0,0 +1,8 @@
+namespace ElectronNET.API
+{
+    internal class MenuResponse
+    {
+        public string id { get; set; }
+        public int windowId { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ElectronNET.API/NativeTheme.cs b/ElectronNET.API/NativeTheme.cs
index 037a97a..9305e8f 100644
--- a/ElectronNET.API/NativeTheme.cs
+++ b/ElectronNET.API/NativeTheme.cs
@@ -94,7 +94,7 @@ namespace ElectronNET.API
         {
             var themeSource = themeSourceMode.GetDescription();
 
-            BridgeConnector.Socket.Emit("nativeTheme-themeSource", themeSource);
+            BridgeConnector.Emit("nativeTheme-themeSource", themeSource);
         }
 
         /// <summary>
@@ -105,16 +105,16 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<ThemeSourceMode>();
 
-            BridgeConnector.Socket.On("nativeTheme-themeSource-getCompleted", (themeSource) =>
+            BridgeConnector.On<string>("nativeTheme-themeSource-getCompleted", (themeSource) =>
             {
-                BridgeConnector.Socket.Off("nativeTheme-themeSource-getCompleted");
+                BridgeConnector.Off("nativeTheme-themeSource-getCompleted");
 
-                var themeSourceValue = (ThemeSourceMode)Enum.Parse(typeof(ThemeSourceMode), (string)themeSource, true);
+                var themeSourceValue = Enum.Parse<ThemeSourceMode>(themeSource, true);
 
                 taskCompletionSource.SetResult(themeSourceValue);
             });
 
-            BridgeConnector.Socket.Emit("nativeTheme-themeSource-get");
+            BridgeConnector.Emit("nativeTheme-themeSource-get");
 
             return taskCompletionSource.Task;
         }
@@ -128,13 +128,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("nativeTheme-shouldUseDarkColors-completed", (shouldUseDarkColors) => {
-                BridgeConnector.Socket.Off("nativeTheme-shouldUseDarkColors-completed");
+            BridgeConnector.On<bool>("nativeTheme-shouldUseDarkColors-completed", (shouldUseDarkColors) => {
+                BridgeConnector.Off("nativeTheme-shouldUseDarkColors-completed");
 
                 taskCompletionSource.SetResult((bool)shouldUseDarkColors);
             });
 
-            BridgeConnector.Socket.Emit("nativeTheme-shouldUseDarkColors");
+            BridgeConnector.Emit("nativeTheme-shouldUseDarkColors");
 
             return taskCompletionSource.Task;
         }
@@ -147,13 +147,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("nativeTheme-shouldUseHighContrastColors-completed", (shouldUseHighContrastColors) => {
-                BridgeConnector.Socket.Off("nativeTheme-shouldUseHighContrastColors-completed");
+            BridgeConnector.On<bool>("nativeTheme-shouldUseHighContrastColors-completed", (shouldUseHighContrastColors) => {
+                BridgeConnector.Off("nativeTheme-shouldUseHighContrastColors-completed");
 
                 taskCompletionSource.SetResult((bool)shouldUseHighContrastColors);
             });
 
-            BridgeConnector.Socket.Emit("nativeTheme-shouldUseHighContrastColors");
+            BridgeConnector.Emit("nativeTheme-shouldUseHighContrastColors");
 
             return taskCompletionSource.Task;
         }
@@ -166,13 +166,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("nativeTheme-shouldUseInvertedColorScheme-completed", (shouldUseInvertedColorScheme) => {
-                BridgeConnector.Socket.Off("nativeTheme-shouldUseInvertedColorScheme-completed");
+            BridgeConnector.On<bool>("nativeTheme-shouldUseInvertedColorScheme-completed", (shouldUseInvertedColorScheme) => {
+                BridgeConnector.Off("nativeTheme-shouldUseInvertedColorScheme-completed");
 
                 taskCompletionSource.SetResult((bool)shouldUseInvertedColorScheme);
             });
 
-            BridgeConnector.Socket.Emit("nativeTheme-shouldUseInvertedColorScheme");
+            BridgeConnector.Emit("nativeTheme-shouldUseInvertedColorScheme");
 
             return taskCompletionSource.Task;
         }
@@ -187,12 +187,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 +202,7 @@ namespace ElectronNET.API
 
                 if (_updated == null)
                 {
-                    BridgeConnector.Socket.Off("nativeTheme-updated" + GetHashCode());
+                    BridgeConnector.Off("nativeTheme-updated" + GetHashCode());
                 }
             }
         }
diff --git a/ElectronNET.API/Notification.cs b/ElectronNET.API/Notification.cs
index 68ac4e1..fcde73b 100644
--- a/ElectronNET.API/Notification.cs
+++ b/ElectronNET.API/Notification.cs
@@ -48,7 +48,7 @@ namespace ElectronNET.API
         {
             GenerateIDsForDefinedActions(notificationOptions);
 
-            BridgeConnector.Socket.Emit("createNotification", JObject.FromObject(notificationOptions, _jsonSerializer));
+            BridgeConnector.Emit("createNotification", JObject.FromObject(notificationOptions, _jsonSerializer));
         }
 
         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());
                 });
             }
 
@@ -126,13 +124,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("notificationIsSupportedComplete", (isSupported) =>
+            BridgeConnector.On<bool>("notificationIsSupportedComplete", (isSupported) =>
             {
-                BridgeConnector.Socket.Off("notificationIsSupportedComplete");
+                BridgeConnector.Off("notificationIsSupportedComplete");
                 taskCompletionSource.SetResult((bool)isSupported);
             });
 
-            BridgeConnector.Socket.Emit("notificationIsSupported");
+            BridgeConnector.Emit("notificationIsSupported");
 
             return taskCompletionSource.Task;
         }
diff --git a/ElectronNET.API/PowerMonitor.cs b/ElectronNET.API/PowerMonitor.cs
index 03e6874..8a7ab80 100644
--- a/ElectronNET.API/PowerMonitor.cs
+++ b/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");
             }
         }
 
diff --git a/ElectronNET.API/Screen.cs b/ElectronNET.API/Screen.cs
index 31cecb5..6c9382f 100644
--- a/ElectronNET.API/Screen.cs
+++ b/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("screen-display-removed-event" + GetHashCode(), (display) =>
                     {
                         _onDisplayRemoved(((JObject)display).ToObject<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,7 +81,7 @@ namespace ElectronNET.API
             {
                 if (_onDisplayMetricsChanged == null)
                 {
-                    BridgeConnector.Socket.On("screen-display-metrics-changed-event" + GetHashCode(), (args) =>
+                    BridgeConnector.On("screen-display-metrics-changed-event" + GetHashCode(), (args) =>
                     {
                         var display = ((JArray)args).First.ToObject<Display>();
                         var metrics = ((JArray)args).Last.ToObject<string[]>();
@@ -89,7 +89,7 @@ namespace ElectronNET.API
                         _onDisplayMetricsChanged(display, metrics);
                     });
 
-                    BridgeConnector.Socket.Emit("register-screen-display-metrics-changed", GetHashCode());
+                    BridgeConnector.Emit("register-screen-display-metrics-changed", GetHashCode());
                 }
                 _onDisplayMetricsChanged += value;
             }
@@ -98,7 +98,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());
             }
         }
 
@@ -136,14 +136,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<Point>();
 
-            BridgeConnector.Socket.On("screen-getCursorScreenPointCompleted", (point) =>
+            BridgeConnector.On("screen-getCursorScreenPointCompleted", (point) =>
             {
-                BridgeConnector.Socket.Off("screen-getCursorScreenPointCompleted");
+                BridgeConnector.Off("screen-getCursorScreenPointCompleted");
 
                 taskCompletionSource.SetResult(((JObject)point).ToObject<Point>());
             });
 
-            BridgeConnector.Socket.Emit("screen-getCursorScreenPoint");
+            BridgeConnector.Emit("screen-getCursorScreenPoint");
 
             return taskCompletionSource.Task;
         }
@@ -156,14 +156,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<int>();
 
-            BridgeConnector.Socket.On("screen-getMenuBarHeightCompleted", (height) =>
+            BridgeConnector.On("screen-getMenuBarHeightCompleted", (height) =>
             {
-                BridgeConnector.Socket.Off("screen-getMenuBarHeightCompleted");
+                BridgeConnector.Off("screen-getMenuBarHeightCompleted");
 
                 taskCompletionSource.SetResult(int.Parse(height.ToString()));
             });
 
-            BridgeConnector.Socket.Emit("screen-getMenuBarHeight");
+            BridgeConnector.Emit("screen-getMenuBarHeight");
 
             return taskCompletionSource.Task;
         }
@@ -176,14 +176,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<Display>();
 
-            BridgeConnector.Socket.On("screen-getPrimaryDisplayCompleted", (display) =>
+            BridgeConnector.On("screen-getPrimaryDisplayCompleted", (display) =>
             {
-                BridgeConnector.Socket.Off("screen-getPrimaryDisplayCompleted");
+                BridgeConnector.Off("screen-getPrimaryDisplayCompleted");
 
                 taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
             });
 
-            BridgeConnector.Socket.Emit("screen-getPrimaryDisplay");
+            BridgeConnector.Emit("screen-getPrimaryDisplay");
 
             return taskCompletionSource.Task;
         }
@@ -196,14 +196,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<Display[]>();
 
-            BridgeConnector.Socket.On("screen-getAllDisplaysCompleted", (displays) =>
+            BridgeConnector.On("screen-getAllDisplaysCompleted", (displays) =>
             {
-                BridgeConnector.Socket.Off("screen-getAllDisplaysCompleted");
+                BridgeConnector.Off("screen-getAllDisplaysCompleted");
 
                 taskCompletionSource.SetResult(((JArray)displays).ToObject<Display[]>());
             });
 
-            BridgeConnector.Socket.Emit("screen-getAllDisplays");
+            BridgeConnector.Emit("screen-getAllDisplays");
 
             return taskCompletionSource.Task;
         }
@@ -216,14 +216,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<Display>();
 
-            BridgeConnector.Socket.On("screen-getDisplayNearestPointCompleted", (display) =>
+            BridgeConnector.On("screen-getDisplayNearestPointCompleted", (display) =>
             {
-                BridgeConnector.Socket.Off("screen-getDisplayNearestPointCompleted");
+                BridgeConnector.Off("screen-getDisplayNearestPointCompleted");
 
                 taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
             });
 
-            BridgeConnector.Socket.Emit("screen-getDisplayNearestPoint", JObject.FromObject(point, _jsonSerializer));
+            BridgeConnector.Emit("screen-getDisplayNearestPoint", JObject.FromObject(point, _jsonSerializer));
 
             return taskCompletionSource.Task;
         }
@@ -237,14 +237,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<Display>();
 
-            BridgeConnector.Socket.On("screen-getDisplayMatching", (display) =>
+            BridgeConnector.On("screen-getDisplayMatching", (display) =>
             {
-                BridgeConnector.Socket.Off("screen-getDisplayMatching");
+                BridgeConnector.Off("screen-getDisplayMatching");
 
                 taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
             });
 
-            BridgeConnector.Socket.Emit("screen-getDisplayMatching", JObject.FromObject(rectangle, _jsonSerializer));
+            BridgeConnector.Emit("screen-getDisplayMatching", JObject.FromObject(rectangle, _jsonSerializer));
 
             return taskCompletionSource.Task;
         }
diff --git a/ElectronNET.API/Session.cs b/ElectronNET.API/Session.cs
index a4cb6bb..097874a 100644
--- a/ElectronNET.API/Session.cs
+++ b/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>
@@ -50,13 +50,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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, JObject.FromObject(options, _jsonSerializer), guid);
 
             return taskCompletionSource.Task;
         }
@@ -69,13 +69,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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;
         }
@@ -89,13 +89,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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;
         }
@@ -109,13 +109,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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;
         }
@@ -129,13 +129,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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;
         }
@@ -150,13 +150,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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, JObject.FromObject(options, _jsonSerializer), 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, JObject.FromObject(options, _jsonSerializer));
         }
 
         /// <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, JObject.FromObject(options, _jsonSerializer));
         }
 
         /// <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>
@@ -210,15 +210,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<int[]>();
             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;
         }
@@ -232,13 +230,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<int>();
             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);
+                BridgeConnector.Off("webContents-session-getCacheSize-completed" + guid);
                 taskCompletionSource.SetResult((int)size);
             });
 
-            BridgeConnector.Socket.Emit("webContents-session-getCacheSize", Id, guid);
+            BridgeConnector.Emit("webContents-session-getCacheSize", Id, guid);
 
             return taskCompletionSource.Task;
         }
@@ -252,14 +250,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string[]>();
             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;
         }
@@ -273,13 +270,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             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;
         }
@@ -295,13 +292,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
             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>
@@ -337,13 +334,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<object>();
             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, JObject.FromObject(config, _jsonSerializer), 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>
@@ -384,15 +381,13 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<ChromeExtensionInfo[]>();
 
-            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>
@@ -438,14 +433,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<Extension>();
 
-            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;
         }
diff --git a/ElectronNET.API/Shell.cs b/ElectronNET.API/Shell.cs
index 71f458e..432fad6 100644
--- a/ElectronNET.API/Shell.cs
+++ b/ElectronNET.API/Shell.cs
@@ -44,12 +44,12 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<object>();
 
-            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;
         }
@@ -63,14 +63,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("shell-openPathCompleted", (errorMessage) =>
+            BridgeConnector.On("shell-openPathCompleted", (errorMessage) =>
             {
-                BridgeConnector.Socket.Off("shell-openPathCompleted");
+                BridgeConnector.Off("shell-openPathCompleted");
 
                 taskCompletionSource.SetResult((string) errorMessage);
             });
 
-            BridgeConnector.Socket.Emit("shell-openPath", path);
+            BridgeConnector.Emit("shell-openPath", path);
 
             return taskCompletionSource.Task;
         }
@@ -97,20 +97,20 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
 
-            BridgeConnector.Socket.On("shell-openExternalCompleted", (error) =>
+            BridgeConnector.On("shell-openExternalCompleted", (error) =>
             {
-                BridgeConnector.Socket.Off("shell-openExternalCompleted");
+                BridgeConnector.Off("shell-openExternalCompleted");
 
                 taskCompletionSource.SetResult((string) 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, JObject.FromObject(options, _jsonSerializer));
             }
 
             return taskCompletionSource.Task;
@@ -125,14 +125,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("shell-trashItem-completed", (success) =>
+            BridgeConnector.On("shell-trashItem-completed", (success) =>
             {
-                BridgeConnector.Socket.Off("shell-trashItem-completed");
+                BridgeConnector.Off("shell-trashItem-completed");
 
                 taskCompletionSource.SetResult((bool) success);
             });
 
-            BridgeConnector.Socket.Emit("shell-trashItem", fullPath);
+            BridgeConnector.Emit("shell-trashItem", fullPath);
 
             return taskCompletionSource.Task;
         }
@@ -142,7 +142,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Beep()
         {
-            BridgeConnector.Socket.Emit("shell-beep");
+            BridgeConnector.Emit("shell-beep");
         }
 
         /// <summary>
@@ -156,14 +156,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("shell-writeShortcutLinkCompleted", (success) =>
+            BridgeConnector.On("shell-writeShortcutLinkCompleted", (success) =>
             {
-                BridgeConnector.Socket.Off("shell-writeShortcutLinkCompleted");
+                BridgeConnector.Off("shell-writeShortcutLinkCompleted");
 
                 taskCompletionSource.SetResult((bool) success);
             });
 
-            BridgeConnector.Socket.Emit("shell-writeShortcutLink", shortcutPath, operation.GetDescription(), JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("shell-writeShortcutLink", shortcutPath, operation.GetDescription(), JObject.FromObject(options, _jsonSerializer));
 
             return taskCompletionSource.Task;
         }
@@ -178,9 +178,9 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<ShortcutDetails>();
 
-            BridgeConnector.Socket.On("shell-readShortcutLinkCompleted", (shortcutDetails) =>
+            BridgeConnector.On("shell-readShortcutLinkCompleted", (shortcutDetails) =>
             {
-                BridgeConnector.Socket.Off("shell-readShortcutLinkCompleted");
+                BridgeConnector.Off("shell-readShortcutLinkCompleted");
 
                 var shortcutObject = shortcutDetails as JObject;
                 var details = shortcutObject?.ToObject<ShortcutDetails>();
@@ -188,7 +188,7 @@ namespace ElectronNET.API
                 taskCompletionSource.SetResult(details);
             });
 
-            BridgeConnector.Socket.Emit("shell-readShortcutLink", shortcutPath);
+            BridgeConnector.Emit("shell-readShortcutLink", shortcutPath);
 
             return taskCompletionSource.Task;
         }
diff --git a/ElectronNET.API/Tray.cs b/ElectronNET.API/Tray.cs
index a5aac8a..bf44cc9 100644
--- a/ElectronNET.API/Tray.cs
+++ b/ElectronNET.API/Tray.cs
@@ -23,7 +23,7 @@ namespace ElectronNET.API
             {
                 if (_click == null)
                 {
-                    BridgeConnector.Socket.On("tray-click-event" + GetHashCode(), (result) =>
+                    BridgeConnector.On("tray-click-event" + GetHashCode(), (result) =>
                     {
                         var args = ((JArray)result).ToObject<object[]>();
                         var trayClickEventArgs = ((JObject)args[0]).ToObject<TrayClickEventArgs>();
@@ -31,7 +31,7 @@ namespace ElectronNET.API
                         _click(trayClickEventArgs, bounds);
                     });
 
-                    BridgeConnector.Socket.Emit("register-tray-click", GetHashCode());
+                    BridgeConnector.Emit("register-tray-click", GetHashCode());
                 }
                 _click += value;
             }
@@ -40,7 +40,7 @@ namespace ElectronNET.API
                 _click -= value;
 
                 if (_click == null)
-                    BridgeConnector.Socket.Off("tray-click-event" + GetHashCode());
+                    BridgeConnector.Off("tray-click-event" + GetHashCode());
             }
         }
 
@@ -55,7 +55,7 @@ namespace ElectronNET.API
             {
                 if (_rightClick == null)
                 {
-                    BridgeConnector.Socket.On("tray-right-click-event" + GetHashCode(), (result) =>
+                    BridgeConnector.On("tray-right-click-event" + GetHashCode(), (result) =>
                     {
                         var args = ((JArray)result).ToObject<object[]>();
                         var trayClickEventArgs = ((JObject)args[0]).ToObject<TrayClickEventArgs>();
@@ -63,7 +63,7 @@ namespace ElectronNET.API
                         _rightClick(trayClickEventArgs, bounds);
                     });
 
-                    BridgeConnector.Socket.Emit("register-tray-right-click", GetHashCode());
+                    BridgeConnector.Emit("register-tray-right-click", GetHashCode());
                 }
                 _rightClick += value;
             }
@@ -72,7 +72,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,7 +87,7 @@ namespace ElectronNET.API
             {
                 if (_doubleClick == null)
                 {
-                    BridgeConnector.Socket.On("tray-double-click-event" + GetHashCode(), (result) =>
+                    BridgeConnector.On("tray-double-click-event" + GetHashCode(), (result) =>
                     {
                         var args = ((JArray)result).ToObject<object[]>();
                         var trayClickEventArgs = ((JObject)args[0]).ToObject<TrayClickEventArgs>();
@@ -95,7 +95,7 @@ namespace ElectronNET.API
                         _doubleClick(trayClickEventArgs, bounds);
                     });
 
-                    BridgeConnector.Socket.Emit("register-tray-double-click", GetHashCode());
+                    BridgeConnector.Emit("register-tray-double-click", GetHashCode());
                 }
                 _doubleClick += value;
             }
@@ -104,7 +104,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 +119,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 +133,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 +148,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 +162,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 +178,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 +192,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 +251,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 +269,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 +277,7 @@ namespace ElectronNET.API
         /// </summary>
         public void Destroy()
         {
-            BridgeConnector.Socket.Emit("tray-destroy");
+            BridgeConnector.Emit("tray-destroy");
             _items.Clear();
         }
 
@@ -287,7 +287,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 +296,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 +305,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 +314,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,7 +323,7 @@ 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", JObject.FromObject(options, _jsonSerializer));
         }
 
         /// <summary>
@@ -334,14 +334,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("tray-isDestroyedCompleted", (isDestroyed) =>
+            BridgeConnector.On<bool>("tray-isDestroyedCompleted", (isDestroyed) =>
             {
-                BridgeConnector.Socket.Off("tray-isDestroyedCompleted");
+                BridgeConnector.Off("tray-isDestroyedCompleted");
 
                 taskCompletionSource.SetResult((bool)isDestroyed);
             });
 
-            BridgeConnector.Socket.Emit("tray-isDestroyed");
+            BridgeConnector.Emit("tray-isDestroyed");
 
             return taskCompletionSource.Task;
         }
diff --git a/ElectronNET.API/WebContents.cs b/ElectronNET.API/WebContents.cs
index 66800d5..943fe8d 100644
--- a/ElectronNET.API/WebContents.cs
+++ b/ElectronNET.API/WebContents.cs
@@ -34,12 +34,12 @@ namespace ElectronNET.API
             {
                 if (_crashed == null)
                 {
-                    BridgeConnector.Socket.On("webContents-crashed" + Id, (killed) =>
+                    BridgeConnector.On("webContents-crashed" + Id, (killed) =>
                     {
                         _crashed((bool)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, JObject.FromObject(openDevToolsOptions, _jsonSerializer));
         }
 
         /// <summary>
@@ -115,14 +115,14 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<PrinterInfo[]>();
 
-            BridgeConnector.Socket.On("webContents-getPrinters-completed", (printers) =>
+            BridgeConnector.On("webContents-getPrinters-completed", (printers) =>
             {
-                BridgeConnector.Socket.Off("webContents-getPrinters-completed");
+                BridgeConnector.Off("webContents-getPrinters-completed");
 
                 taskCompletionSource.SetResult(((Newtonsoft.Json.Linq.JArray)printers).ToObject<PrinterInfo[]>());
             });
 
-            BridgeConnector.Socket.Emit("webContents-getPrinters", Id);
+            BridgeConnector.Emit("webContents-getPrinters", Id);
 
             return taskCompletionSource.Task;
         }
@@ -136,19 +136,19 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("webContents-print-completed", (success) =>
+            BridgeConnector.On("webContents-print-completed", (success) =>
             {
-                BridgeConnector.Socket.Off("webContents-print-completed");
+                BridgeConnector.Off("webContents-print-completed");
                 taskCompletionSource.SetResult((bool)success);
             });
 
             if(options == null)
             {
-                BridgeConnector.Socket.Emit("webContents-print", Id, "");
+                BridgeConnector.Emit("webContents-print", Id, "");
             }
             else
             {
-                BridgeConnector.Socket.Emit("webContents-print", Id, JObject.FromObject(options, _jsonSerializer));
+                BridgeConnector.Emit("webContents-print", Id, JObject.FromObject(options, _jsonSerializer));
             }
 
             return taskCompletionSource.Task;
@@ -167,19 +167,19 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("webContents-printToPDF-completed", (success) =>
+            BridgeConnector.On("webContents-printToPDF-completed", (success) =>
             {
-                BridgeConnector.Socket.Off("webContents-printToPDF-completed");
+                BridgeConnector.Off("webContents-printToPDF-completed");
                 taskCompletionSource.SetResult((bool)success);
             });
 
             if(options == null)
             {
-                BridgeConnector.Socket.Emit("webContents-printToPDF", Id, "", path);
+                BridgeConnector.Emit("webContents-printToPDF", Id, "", path);
             }
             else
             {
-                BridgeConnector.Socket.Emit("webContents-printToPDF", Id, JObject.FromObject(options, _jsonSerializer), path);
+                BridgeConnector.Emit("webContents-printToPDF", Id, JObject.FromObject(options, _jsonSerializer), path);
             }
 
             return taskCompletionSource.Task;
@@ -195,13 +195,13 @@ namespace ElectronNET.API
             var taskCompletionSource = new TaskCompletionSource<string>();
 
             var eventString = "webContents-getUrl" + Id;
-            BridgeConnector.Socket.On(eventString, (url) =>
+            BridgeConnector.On(eventString, (url) =>
             {
-                BridgeConnector.Socket.Off(eventString);
+                BridgeConnector.Off(eventString);
                 taskCompletionSource.SetResult((string)url);
             });
 
-            BridgeConnector.Socket.Emit("webContents-getUrl", Id);
+            BridgeConnector.Emit("webContents-getUrl", Id);
 
             return taskCompletionSource.Task;
         }
@@ -240,20 +240,20 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<object>();
 
-            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);
+                BridgeConnector.Off("webContents-loadURL-complete" + Id);
+                BridgeConnector.Off("webContents-loadURL-error" + Id);
                 taskCompletionSource.SetResult(null);
             });
 
-            BridgeConnector.Socket.On("webContents-loadURL-error" + Id, (error) =>
+            BridgeConnector.On("webContents-loadURL-error" + Id, (error) =>
             {
-                BridgeConnector.Socket.Off("webContents-loadURL-error" + Id);
+                BridgeConnector.Off("webContents-loadURL-error" + Id);
                 taskCompletionSource.SetException(new InvalidOperationException(error.ToString()));
             });
 
-            BridgeConnector.Socket.Emit("webContents-loadURL", Id, url, JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("webContents-loadURL", Id, url, JObject.FromObject(options, _jsonSerializer));
 
             return taskCompletionSource.Task;
         }
@@ -267,7 +267,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()
diff --git a/ElectronNET.API/WindowManager.cs b/ElectronNET.API/WindowManager.cs
index 4ac85da..b156497 100644
--- a/ElectronNET.API/WindowManager.cs
+++ b/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;
             }
         }
@@ -94,22 +94,19 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<BrowserWindow>();
 
-            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", JObject.FromObject(options, _jsonSerializer), loadUrl);
             }
             else
             {
@@ -153,7 +150,7 @@ 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;
@@ -186,12 +183,11 @@ namespace ElectronNET.API
         {
             var taskCompletionSource = new TaskCompletionSource<BrowserView>();
 
-            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);
 
@@ -203,7 +199,7 @@ namespace ElectronNET.API
                 ContractResolver = new CamelCasePropertyNamesContractResolver(),
                 NullValueHandling = NullValueHandling.Ignore
             };
-            BridgeConnector.Socket.Emit("createBrowserView", JObject.FromObject(options, ownjsonSerializer));
+            BridgeConnector.Emit("createBrowserView", JObject.FromObject(options, ownjsonSerializer));
 
             return taskCompletionSource.Task;
         }
diff --git a/ElectronNET.CLI/ElectronNET.CLI.csproj b/ElectronNET.CLI/ElectronNET.CLI.csproj
index 7c33bf3..1569a43 100644
--- a/ElectronNET.CLI/ElectronNET.CLI.csproj
+++ b/ElectronNET.CLI/ElectronNET.CLI.csproj
@@ -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" />
diff --git a/ElectronNET.Host/api/app.js b/ElectronNET.Host/api/app.js
index 783b204..d7e504d 100644
--- a/ElectronNET.Host/api/app.js
+++ b/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', new { args: args, workingDirectory: workingDirectory }]);
         });
     });
     socket.on('appHasSingleInstanceLock', () => {
diff --git a/ElectronNET.Host/api/dialog.js b/ElectronNET.Host/api/dialog.js
index 20f9572..33c287d 100644
--- a/ElectronNET.Host/api/dialog.js
+++ b/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, new { 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, new { response: messageBoxReturnValue.response, checked: messageBoxReturnValue.checkboxChecked });
         }
     });
     socket.on('showOpenDialog', async (browserWindow, options, guid) => {
diff --git a/ElectronNET.Host/api/menu.js b/ElectronNET.Host/api/menu.js
index 2500036..0125df3 100644
--- a/ElectronNET.Host/api/menu.js
+++ b/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', new { id: id, windowId: windowId });
         });
         const index = contextMenuItems.findIndex(contextMenu => contextMenu.browserWindowId === browserWindowId);
         const contextMenuItem = {
diff --git a/ElectronNET.Host/api/webContents.js b/ElectronNET.Host/api/webContents.js
index 71829a8..932c4c3 100644
--- a/ElectronNET.Host/api/webContents.js
+++ b/ElectronNET.Host/api/webContents.js
@@ -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, new { cookie: cookie, cause: cause, removed: removed });
         });
     });
     socket.on('webContents-session-cookies-get', async (id, filter, guid) => {
diff --git a/ElectronNET.WebApp/ElectronNET.WebApp.csproj b/ElectronNET.WebApp/ElectronNET.WebApp.csproj
index 4b7e231..e9fe1c2 100644
--- a/ElectronNET.WebApp/ElectronNET.WebApp.csproj
+++ b/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" />
diff --git a/ElectronNET.WebApp/Program.cs b/ElectronNET.WebApp/Program.cs
index 6a32e60..c79b260 100644
--- a/ElectronNET.WebApp/Program.cs
+++ b/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,7 @@ namespace ElectronNET.WebApp
     {
         public static void Main(string[] args)
         {
+            Debugger.Launch();
             CreateWebHostBuilder(args).Build().Run();
         }
 
diff --git a/ElectronNET.WebApp/electron.manifest.json b/ElectronNET.WebApp/electron.manifest.json
index 3053f9a..11001ea 100644
--- a/ElectronNET.WebApp/electron.manifest.json
+++ b/ElectronNET.WebApp/electron.manifest.json
@@ -1,6 +1,6 @@
 {
   "executable": "ElectronNET.WebApp",
-  "splashscreen": {
+  "splashscreen2": {
     "imageFile": "/wwwroot/assets/img/about@2x.png"
   },
   "environment": "Production",