diff --git a/ElectronNET.API/App.cs b/ElectronNET.API/App.cs
index 68463e3..7a66589 100644
--- a/ElectronNET.API/App.cs
+++ b/ElectronNET.API/App.cs
@@ -464,40 +464,49 @@ namespace ElectronNET.API
         /// The current application directory.
         /// </summary>
         /// <returns></returns>
-        public async Task<string> GetAppPathAsync()
+        public async Task<string> GetAppPathAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("appGetAppPathCompleted", (path) =>
+            using(cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetAppPathCompleted");
-                taskCompletionSource.SetResult(path.ToString());
-            });
+                BridgeConnector.Socket.On("appGetAppPathCompleted", (path) =>
+                {
+                    BridgeConnector.Socket.Off("appGetAppPathCompleted");
+                    taskCompletionSource.SetResult(path.ToString());
+                });
 
-            BridgeConnector.Socket.Emit("appGetAppPath");
+                BridgeConnector.Socket.Emit("appGetAppPath");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }            
         }
 
         /// <summary>
         /// You can request the following paths by the name.
         /// </summary>
-        /// <param name="pathName"></param>
         /// <returns>A path to a special directory or file associated with name.</returns>
-        public async Task<string> GetPathAsync(PathName pathName)
+        public async Task<string> GetPathAsync(PathName pathName, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<string>();
+            using(cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("appGetPathCompleted", (path) =>
+                {
+                    BridgeConnector.Socket.Off("appGetPathCompleted");
 
-            BridgeConnector.Socket.On("appGetPathCompleted", (path) =>
-                    {
-                        BridgeConnector.Socket.Off("appGetPathCompleted");
+                    taskCompletionSource.SetResult(path.ToString());
+                });
 
-                        taskCompletionSource.SetResult(path.ToString());
-                    });
+                BridgeConnector.Socket.Emit("appGetPath", pathName.ToString());
 
-            BridgeConnector.Socket.Emit("appGetPath", pathName.ToString());
-
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }  
         }
 
 
@@ -522,19 +531,24 @@ namespace ElectronNET.API
         /// the version of the current bundle or executable is returned.
         /// </summary>
         /// <returns></returns>
-        public async Task<string> GetVersionAsync()
+        public async Task<string> GetVersionAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("appGetVersionCompleted", (version) =>
+            using(cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetVersionCompleted");
-                taskCompletionSource.SetResult(version.ToString());
-            });
+                BridgeConnector.Socket.On("appGetVersionCompleted", (version) =>
+                {
+                    BridgeConnector.Socket.Off("appGetVersionCompleted");
+                    taskCompletionSource.SetResult(version.ToString());
+                });
 
-            BridgeConnector.Socket.Emit("appGetVersion");
+                BridgeConnector.Socket.Emit("appGetVersion");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -544,19 +558,24 @@ namespace ElectronNET.API
         /// name by Electron.
         /// </summary>
         /// <returns>The current application’s name, which is the name in the application’s package.json file.</returns>
-        public async Task<string> GetNameAsync()
+        public async Task<string> GetNameAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("appGetNameCompleted", (name) =>
+            using(cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetNameCompleted");
-                taskCompletionSource.SetResult(name.ToString());
-            });
+                BridgeConnector.Socket.On("appGetNameCompleted", (name) =>
+                {
+                    BridgeConnector.Socket.Off("appGetNameCompleted");
+                    taskCompletionSource.SetResult(name.ToString());
+                });
 
-            BridgeConnector.Socket.Emit("appGetName");
+                BridgeConnector.Socket.Emit("appGetName");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -574,19 +593,24 @@ namespace ElectronNET.API
         ///  folder.Note: On Windows you have to call it after the ready events gets emitted.
         /// </summary>
         /// <returns></returns>
-        public async Task<string> GetLocaleAsync()
+        public async Task<string> GetLocaleAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("appGetLocaleCompleted", (locale) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetLocaleCompleted");
-                taskCompletionSource.SetResult(locale.ToString());
-            });
+                BridgeConnector.Socket.On("appGetLocaleCompleted", (local) =>
+                {
+                    BridgeConnector.Socket.Off("appGetLocaleCompleted");
+                    taskCompletionSource.SetResult(local.ToString());
+                });
 
-            BridgeConnector.Socket.Emit("appGetLocale");
+                BridgeConnector.Socket.Emit("appGetLocale");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -625,20 +649,26 @@ namespace ElectronNET.API
         /// <param name="protocol">The name of your protocol, without ://. 
         /// If you want your app to handle electron:// links, 
         /// call this method with electron as the parameter.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Whether the call succeeded.</returns>
-        public async Task<bool> SetAsDefaultProtocolClientAsync(string protocol)
+        public async Task<bool> SetAsDefaultProtocolClientAsync(string protocol, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appSetAsDefaultProtocolClientCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appSetAsDefaultProtocolClientCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appSetAsDefaultProtocolClientCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appSetAsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appSetAsDefaultProtocolClient", protocol);
+                BridgeConnector.Socket.Emit("appSetAsDefaultProtocolClient", protocol);
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -659,20 +689,26 @@ namespace ElectronNET.API
         /// If you want your app to handle electron:// links, 
         /// call this method with electron as the parameter.</param>
         /// <param name="path">Defaults to process.execPath</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Whether the call succeeded.</returns>
-        public async Task<bool> SetAsDefaultProtocolClientAsync(string protocol, string path)
+        public async Task<bool> SetAsDefaultProtocolClientAsync(string protocol, string path, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appSetAsDefaultProtocolClientCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appSetAsDefaultProtocolClientCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appSetAsDefaultProtocolClientCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appSetAsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appSetAsDefaultProtocolClient", protocol, path);
+                BridgeConnector.Socket.Emit("appSetAsDefaultProtocolClient", protocol, path);
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -694,20 +730,26 @@ namespace ElectronNET.API
         /// call this method with electron as the parameter.</param>
         /// <param name="path">Defaults to process.execPath</param>
         /// <param name="args">Defaults to an empty array</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Whether the call succeeded.</returns>
-        public async Task<bool> SetAsDefaultProtocolClientAsync(string protocol, string path, string[] args)
+        public async Task<bool> SetAsDefaultProtocolClientAsync(string protocol, string path, string[] args, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appSetAsDefaultProtocolClientCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appSetAsDefaultProtocolClientCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appSetAsDefaultProtocolClientCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appSetAsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appSetAsDefaultProtocolClient", protocol, path, args);
+                BridgeConnector.Socket.Emit("appSetAsDefaultProtocolClient", protocol, path, args);
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -715,20 +757,26 @@ namespace ElectronNET.API
         /// protocol(aka URI scheme). If so, it will remove the app as the default handler.
         /// </summary>
         /// <param name="protocol">The name of your protocol, without ://.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Whether the call succeeded.</returns>
-        public async Task<bool> RemoveAsDefaultProtocolClientAsync(string protocol)
+        public async Task<bool> RemoveAsDefaultProtocolClientAsync(string protocol, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appRemoveAsDefaultProtocolClientCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appRemoveAsDefaultProtocolClientCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appRemoveAsDefaultProtocolClientCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appRemoveAsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appRemoveAsDefaultProtocolClient", protocol);
+                BridgeConnector.Socket.Emit("appRemoveAsDefaultProtocolClient", protocol);
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -737,20 +785,26 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="protocol">The name of your protocol, without ://.</param>
         /// <param name="path">Defaults to process.execPath.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Whether the call succeeded.</returns>
-        public async Task<bool> RemoveAsDefaultProtocolClientAsync(string protocol, string path)
+        public async Task<bool> RemoveAsDefaultProtocolClientAsync(string protocol, string path, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appRemoveAsDefaultProtocolClientCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appRemoveAsDefaultProtocolClientCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appRemoveAsDefaultProtocolClientCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appRemoveAsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appRemoveAsDefaultProtocolClient", protocol, path);
+                BridgeConnector.Socket.Emit("appRemoveAsDefaultProtocolClient", protocol, path);
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -760,20 +814,26 @@ namespace ElectronNET.API
         /// <param name="protocol">The name of your protocol, without ://.</param>
         /// <param name="path">Defaults to process.execPath.</param>
         /// <param name="args">Defaults to an empty array.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Whether the call succeeded.</returns>
-        public async Task<bool> RemoveAsDefaultProtocolClientAsync(string protocol, string path, string[] args)
-        {
+        public async Task<bool> RemoveAsDefaultProtocolClientAsync(string protocol, string path, string[] args, CancellationToken cancellationToken = default(CancellationToken))
+        {           
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appRemoveAsDefaultProtocolClientCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appRemoveAsDefaultProtocolClientCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appRemoveAsDefaultProtocolClientCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appRemoveAsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appRemoveAsDefaultProtocolClient", protocol, path, args);
+                BridgeConnector.Socket.Emit("appRemoveAsDefaultProtocolClient", protocol, path, args);
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -786,20 +846,26 @@ namespace ElectronNET.API
         /// the Windows Registry and LSCopyDefaultHandlerForURLScheme internally.
         /// </summary>
         /// <param name="protocol">The name of your protocol, without ://.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Returns Boolean</returns>
-        public async Task<bool> IsDefaultProtocolClientAsync(string protocol)
+        public async Task<bool> IsDefaultProtocolClientAsync(string protocol, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appIsDefaultProtocolClientCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appIsDefaultProtocolClientCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appIsDefaultProtocolClientCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appIsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appIsDefaultProtocolClient", protocol);
+                BridgeConnector.Socket.Emit("appIsDefaultProtocolClient", protocol);
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }            
         }
 
         /// <summary>
@@ -813,20 +879,26 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="protocol">The name of your protocol, without ://.</param>
         /// <param name="path">Defaults to process.execPath.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Returns Boolean</returns>
-        public async Task<bool> IsDefaultProtocolClientAsync(string protocol, string path)
+        public async Task<bool> IsDefaultProtocolClientAsync(string protocol, string path, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appIsDefaultProtocolClientCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appIsDefaultProtocolClientCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appIsDefaultProtocolClientCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appIsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appIsDefaultProtocolClient", protocol, path);
+                BridgeConnector.Socket.Emit("appIsDefaultProtocolClient", protocol, path);
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -841,20 +913,26 @@ namespace ElectronNET.API
         /// <param name="protocol">The name of your protocol, without ://.</param>
         /// <param name="path">Defaults to process.execPath.</param>
         /// <param name="args">Defaults to an empty array.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Returns Boolean</returns>
-        public async Task<bool> IsDefaultProtocolClientAsync(string protocol, string path, string[] args)
+        public async Task<bool> IsDefaultProtocolClientAsync(string protocol, string path, string[] args, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appIsDefaultProtocolClientCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appIsDefaultProtocolClientCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appIsDefaultProtocolClientCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appIsDefaultProtocolClientCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appIsDefaultProtocolClient", protocol, path, args);
+                BridgeConnector.Socket.Emit("appIsDefaultProtocolClient", protocol, path, args);
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -863,39 +941,50 @@ namespace ElectronNET.API
         /// app.setJumpList(categories) instead.
         /// </summary>
         /// <param name="userTasks">Array of Task objects.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Whether the call succeeded.</returns>
-        public async Task<bool> SetUserTasksAsync(UserTask[] userTasks)
+        public async Task<bool> SetUserTasksAsync(UserTask[] userTasks, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appSetUserTasksCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appSetUserTasksCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appSetUserTasksCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appSetUserTasksCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appSetUserTasks", JObject.FromObject(userTasks, _jsonSerializer));
+                BridgeConnector.Socket.Emit("appSetUserTasks", JObject.FromObject(userTasks, _jsonSerializer));
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
         /// Jump List settings for the application.
         /// </summary>
         /// <returns></returns>
-        public async Task<JumpListSettings> GetJumpListSettingsAsync()
+        public async Task<JumpListSettings> GetJumpListSettingsAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<JumpListSettings>();
-
-            BridgeConnector.Socket.On("appGetJumpListSettingsCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetJumpListSettingsCompleted");
-                taskCompletionSource.SetResult(JObject.Parse(success.ToString()).ToObject<JumpListSettings>());
-            });
+                BridgeConnector.Socket.On("appGetJumpListSettingsCompleted", (jumplistSettings) =>
+                {
+                    BridgeConnector.Socket.Off("appGetJumpListSettingsCompleted");
+                    taskCompletionSource.SetResult(JObject.Parse(jumplistSettings.ToString()).ToObject<JumpListSettings>());
+                });
 
-            BridgeConnector.Socket.Emit("appGetJumpListSettings");
+                BridgeConnector.Socket.Emit("appGetJumpListSettings");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -939,32 +1028,38 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="newInstanceOpened">Lambda with an array of the second instance’s command line arguments.
         /// The second parameter is the working directory path.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>This method returns false if your process is the primary instance of 
         /// the application and your app should continue loading. And returns true if your 
         /// process has sent its parameters to another instance, and you should immediately quit.</returns>
-        public async Task<bool> MakeSingleInstanceAsync(Action<string[], string> newInstanceOpened)
+        public async Task<bool> MakeSingleInstanceAsync(Action<string[], string> newInstanceOpened, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appMakeSingleInstanceCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appMakeSingleInstanceCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appMakeSingleInstanceCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appMakeSingleInstanceCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Off("newInstanceOpened");
-            BridgeConnector.Socket.On("newInstanceOpened", (result) =>
-            {
-                JArray results = (JArray)result;
-                string[] args = results.First.ToObject<string[]>();
-                string workdirectory = results.Last.ToObject<string>();
+                BridgeConnector.Socket.Off("newInstanceOpened");
+                BridgeConnector.Socket.On("newInstanceOpened", (result) =>
+                {
+                    JArray results = (JArray)result;
+                    string[] args = results.First.ToObject<string[]>();
+                    string workdirectory = results.Last.ToObject<string>();
 
-                newInstanceOpened(args, workdirectory);
-            });
+                    newInstanceOpened(args, workdirectory);
+                });
 
-            BridgeConnector.Socket.Emit("appMakeSingleInstance");
+                BridgeConnector.Socket.Emit("appMakeSingleInstance");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -1003,19 +1098,24 @@ namespace ElectronNET.API
         /// The type of the currently running activity.
         /// </summary>
         /// <returns></returns>
-        public async Task<string> GetCurrentActivityTypeAsync()
+        public async Task<string> GetCurrentActivityTypeAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("appGetCurrentActivityTypeCompleted", (activityType) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetCurrentActivityTypeCompleted");
-                taskCompletionSource.SetResult(activityType.ToString());
-            });
+                BridgeConnector.Socket.On("appGetCurrentActivityTypeCompleted", (activityType) =>
+                {
+                    BridgeConnector.Socket.Off("appGetCurrentActivityTypeCompleted");
+                    taskCompletionSource.SetResult(activityType.ToString());
+                });
 
-            BridgeConnector.Socket.Emit("appGetCurrentActivityType");
+                BridgeConnector.Socket.Emit("appGetCurrentActivityType");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -1033,62 +1133,78 @@ namespace ElectronNET.API
         /// success while any other value indicates failure according to chromium net_error_list.
         /// </summary>
         /// <param name="options"></param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>Result of import. Value of 0 indicates success.</returns>
-        public async Task<int> ImportCertificateAsync(ImportCertificateOptions options)
+        public async Task<int> ImportCertificateAsync(ImportCertificateOptions options, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<int>();
-
-            BridgeConnector.Socket.On("appImportCertificateCompleted", (result) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appImportCertificateCompleted");
-                taskCompletionSource.SetResult((int)result);
-            });
+                BridgeConnector.Socket.On("appImportCertificateCompleted", (result) =>
+                {
+                    BridgeConnector.Socket.Off("appImportCertificateCompleted");
+                    taskCompletionSource.SetResult((int)result);
+                });
 
-            BridgeConnector.Socket.Emit("appImportCertificate", JObject.FromObject(options, _jsonSerializer));
+                BridgeConnector.Socket.Emit("appImportCertificate", JObject.FromObject(options, _jsonSerializer));
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
         /// Memory and cpu usage statistics of all the processes associated with the app.
         /// </summary>
         /// <returns></returns>
-        public async Task<ProcessMetric[]> GetAppMetricsAsync()
+        public async Task<ProcessMetric[]> GetAppMetricsAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<ProcessMetric[]>();
-
-            BridgeConnector.Socket.On("appGetAppMetricsCompleted", (result) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetAppMetricsCompleted");
-                var processMetrics = ((JArray)result).ToObject<ProcessMetric[]>();
+                BridgeConnector.Socket.On("appGetAppMetricsCompleted", (result) =>
+                {
+                    BridgeConnector.Socket.Off("appGetAppMetricsCompleted");
+                    var processMetrics = ((JArray)result).ToObject<ProcessMetric[]>();
 
-                taskCompletionSource.SetResult(processMetrics);
-            });
+                    taskCompletionSource.SetResult(processMetrics);
+                });
 
-            BridgeConnector.Socket.Emit("appGetAppMetrics");
+                BridgeConnector.Socket.Emit("appGetAppMetrics");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
         /// The Graphics Feature Status from chrome://gpu/.
         /// </summary>
         /// <returns></returns>
-        public async Task<GPUFeatureStatus> GetGpuFeatureStatusAsync()
+        public async Task<GPUFeatureStatus> GetGpuFeatureStatusAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<GPUFeatureStatus>();
-
-            BridgeConnector.Socket.On("appGetGpuFeatureStatusCompleted", (result) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetGpuFeatureStatusCompleted");
-                var gpuFeatureStatus = ((JObject)result).ToObject<GPUFeatureStatus>();
+                BridgeConnector.Socket.On("appGetGpuFeatureStatusCompleted", (result) =>
+                {
+                    BridgeConnector.Socket.Off("appGetGpuFeatureStatusCompleted");
+                    var gpuFeatureStatus = ((JObject)result).ToObject<GPUFeatureStatus>();
 
-                taskCompletionSource.SetResult(gpuFeatureStatus);
-            });
+                    taskCompletionSource.SetResult(gpuFeatureStatus);
+                });
 
-            BridgeConnector.Socket.Emit("appGetGpuFeatureStatus");
+                BridgeConnector.Socket.Emit("appGetGpuFeatureStatus");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -1099,57 +1215,72 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="count"></param>
         /// <returns>Whether the call succeeded.</returns>
-        public async Task<bool> SetBadgeCountAsync(int count)
+        public async Task<bool> SetBadgeCountAsync(int count, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appSetBadgeCountCompleted", (success) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appSetBadgeCountCompleted");
-                taskCompletionSource.SetResult((bool)success);
-            });
+                BridgeConnector.Socket.On("appSetBadgeCountCompleted", (success) =>
+                {
+                    BridgeConnector.Socket.Off("appSetBadgeCountCompleted");
+                    taskCompletionSource.SetResult((bool)success);
+                });
 
-            BridgeConnector.Socket.Emit("appSetBadgeCount", count);
+                BridgeConnector.Socket.Emit("appSetBadgeCount");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
         /// The current value displayed in the counter badge.
         /// </summary>
         /// <returns></returns>
-        public async Task<int> GetBadgeCountAsync()
+        public async Task<int> GetBadgeCountAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<int>();
-
-            BridgeConnector.Socket.On("appGetBadgeCountCompleted", (count) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetBadgeCountCompleted");
-                taskCompletionSource.SetResult((int)count);
-            });
+                BridgeConnector.Socket.On("appGetBadgeCountCompleted", (count) =>
+                {
+                    BridgeConnector.Socket.Off("appGetBadgeCountCompleted");
+                    taskCompletionSource.SetResult((int)count);
+                });
 
-            BridgeConnector.Socket.Emit("appGetBadgeCount");
+                BridgeConnector.Socket.Emit("appGetBadgeCount");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
         /// Whether the current desktop environment is Unity launcher.
         /// </summary>
         /// <returns></returns>
-        public async Task<bool> IsUnityRunningAsync()
+        public async Task<bool> IsUnityRunningAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appIsUnityRunningCompleted", (isUnityRunning) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appIsUnityRunningCompleted");
-                taskCompletionSource.SetResult((bool)isUnityRunning);
-            });
+                BridgeConnector.Socket.On("appIsUnityRunningCompleted", (isUnityRunning) =>
+                {
+                    BridgeConnector.Socket.Off("appIsUnityRunningCompleted");
+                    taskCompletionSource.SetResult((bool)isUnityRunning);
+                });
 
-            BridgeConnector.Socket.Emit("appIsUnityRunning");
+                BridgeConnector.Socket.Emit("appIsUnityRunning");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -1158,19 +1289,24 @@ namespace ElectronNET.API
         /// API has no effect on MAS builds.
         /// </summary>
         /// <returns></returns>
-        public async Task<LoginItemSettings> GetLoginItemSettingsAsync()
+        public async Task<LoginItemSettings> GetLoginItemSettingsAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<LoginItemSettings>();
-
-            BridgeConnector.Socket.On("appGetLoginItemSettingsCompleted", (loginItemSettings) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetLoginItemSettingsCompleted");
-                taskCompletionSource.SetResult((LoginItemSettings)loginItemSettings);
-            });
+                BridgeConnector.Socket.On("appGetLoginItemSettingsCompleted", (loginItemSettings) =>
+                {
+                    BridgeConnector.Socket.Off("appGetLoginItemSettingsCompleted");
+                    taskCompletionSource.SetResult((LoginItemSettings)loginItemSettings);
+                });
 
-            BridgeConnector.Socket.Emit("appGetLoginItemSettings");
+                BridgeConnector.Socket.Emit("appGetLoginItemSettings");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -1179,20 +1315,26 @@ namespace ElectronNET.API
         /// API has no effect on MAS builds.
         /// </summary>
         /// <param name="options"></param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns></returns>
-        public async Task<LoginItemSettings> GetLoginItemSettingsAsync(LoginItemSettingsOptions options)
+        public async Task<LoginItemSettings> GetLoginItemSettingsAsync(LoginItemSettingsOptions options, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<LoginItemSettings>();
-
-            BridgeConnector.Socket.On("appGetLoginItemSettingsCompleted", (loginItemSettings) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appGetLoginItemSettingsCompleted");
-                taskCompletionSource.SetResult((LoginItemSettings)loginItemSettings);
-            });
+                BridgeConnector.Socket.On("appGetLoginItemSettingsCompleted", (loginItemSettings) =>
+                {
+                    BridgeConnector.Socket.Off("appGetLoginItemSettingsCompleted");
+                    taskCompletionSource.SetResult((LoginItemSettings)loginItemSettings);
+                });
 
-            BridgeConnector.Socket.Emit("appGetLoginItemSettings", JObject.FromObject(options, _jsonSerializer));
+                BridgeConnector.Socket.Emit("appGetLoginItemSettings", JObject.FromObject(options, _jsonSerializer));
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -1212,19 +1354,24 @@ namespace ElectronNET.API
         /// See https://www.chromium.org/developers/design-documents/accessibility for more details.
         /// </summary>
         /// <returns>true if Chrome’s accessibility support is enabled, false otherwise.</returns>
-        public async Task<bool> IsAccessibilitySupportEnabledAsync()
+        public async Task<bool> IsAccessibilitySupportEnabledAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appIsAccessibilitySupportEnabledCompleted", (isAccessibilitySupportEnabled) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appIsAccessibilitySupportEnabledCompleted");
-                taskCompletionSource.SetResult((bool)isAccessibilitySupportEnabled);
-            });
+                BridgeConnector.Socket.On("appIsAccessibilitySupportEnabledCompleted", (isAccessibilitySupportEnabled) =>
+                {
+                    BridgeConnector.Socket.Off("appIsAccessibilitySupportEnabledCompleted");
+                    taskCompletionSource.SetResult((bool)isAccessibilitySupportEnabled);
+                });
 
-            BridgeConnector.Socket.Emit("appIsAccessibilitySupportEnabled");
+                BridgeConnector.Socket.Emit("appIsAccessibilitySupportEnabled");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -1285,20 +1432,26 @@ namespace ElectronNET.API
         /// either the application becomes active or the request is canceled.
         /// </summary>
         /// <param name="type"></param>
+        /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task<int> DockBounceAsync(DockBounceType type)
+        public async Task<int> DockBounceAsync(DockBounceType type, CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<int>();
-
-            BridgeConnector.Socket.On("appDockBounceCompleted", (id) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appDockBounceCompleted");
-                taskCompletionSource.SetResult((int)id);
-            });
+                BridgeConnector.Socket.On("appDockBounceCompleted", (id) =>
+                {
+                    BridgeConnector.Socket.Off("appDockBounceCompleted");
+                    taskCompletionSource.SetResult((int)id);
+                });
 
-            BridgeConnector.Socket.Emit("appDockBounce", type.ToString());
+                BridgeConnector.Socket.Emit("appDockBounce", type.ToString());
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -1332,19 +1485,24 @@ namespace ElectronNET.API
         /// Gets the string to be displayed in the dock’s badging area.
         /// </summary>
         /// <returns></returns>
-        public async Task<string> DockGetBadgeAsync()
+        public async Task<string> DockGetBadgeAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("appDockGetBadgeCompleted", (text) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appDockGetBadgeCompleted");
-                taskCompletionSource.SetResult((string)text);
-            });
+                BridgeConnector.Socket.On("appDockGetBadgeCompleted", (text) =>
+                {
+                    BridgeConnector.Socket.Off("appDockGetBadgeCompleted");
+                    taskCompletionSource.SetResult((string)text);
+                });
 
-            BridgeConnector.Socket.Emit("appDockGetBadge");
+                BridgeConnector.Socket.Emit("appDockGetBadge");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         /// <summary>
@@ -1368,19 +1526,24 @@ namespace ElectronNET.API
         /// so this method might not return true immediately after that call.
         /// </summary>
         /// <returns></returns>
-        public async Task<bool> DockIsVisibleAsync()
+        public async Task<bool> DockIsVisibleAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             var taskCompletionSource = new TaskCompletionSource<bool>();
-
-            BridgeConnector.Socket.On("appDockIsVisibleCompleted", (isVisible) =>
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
-                BridgeConnector.Socket.Off("appDockIsVisibleCompleted");
-                taskCompletionSource.SetResult((bool)isVisible);
-            });
+                BridgeConnector.Socket.On("appDockIsVisibleCompleted", (isVisible) =>
+                {
+                    BridgeConnector.Socket.Off("appDockIsVisibleCompleted");
+                    taskCompletionSource.SetResult((bool)isVisible);
+                });
 
-            BridgeConnector.Socket.Emit("appDockIsVisible");
+                BridgeConnector.Socket.Emit("appDockIsVisible");
 
-            return await taskCompletionSource.Task;
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
         }
 
         // TODO: Menu lösung für macOS muss gemacht werden und imeplementiert