/// <summary>
        /// Disconnects from the wireless LAN associated to a specified wireless interface.
        /// </summary>
        /// <param name="interfaceId">Interface ID</param>
        /// <returns>True if successfully requested the disconnection. False if failed.</returns>
        public static bool DisconnectNetwork(Guid interfaceId)
        {
            if (interfaceId == Guid.Empty)
            {
                throw new ArgumentException(nameof(interfaceId));
            }

            using (var client = new Base.WlanClient())
            {
                return(Base.Disconnect(client.Handle, interfaceId));
            }
        }
        /// <summary>
        /// Asynchronously disconnects from the wireless LAN associated to a specified wireless interface.
        /// </summary>
        /// <param name="interfaceId">Interface ID</param>
        /// <param name="timeout">Timeout duration</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>True if successfully disconnected. False if failed or timed out.</returns>
        public static async Task <bool> DisconnectNetworkAsync(Guid interfaceId, TimeSpan timeout, CancellationToken cancellationToken)
        {
            if (interfaceId == Guid.Empty)
            {
                throw new ArgumentException(nameof(interfaceId));
            }

            if (timeout < TimeSpan.Zero)
            {
                throw new ArgumentException(nameof(timeout));
            }

            using (var client = new Base.WlanClient())
            {
                var tcs = new TaskCompletionSource <bool>();

                Action <IntPtr, IntPtr> callback = (data, context) =>
                {
                    var notificationData = Marshal.PtrToStructure <WLAN_NOTIFICATION_DATA>(data);
                    if (notificationData.NotificationSource != WLAN_NOTIFICATION_SOURCE_ACM)
                    {
                        return;
                    }

                    Debug.WriteLine("Callback: {0}", (WLAN_NOTIFICATION_ACM)notificationData.NotificationCode);

                    switch (notificationData.NotificationCode)
                    {
                    case (uint)WLAN_NOTIFICATION_ACM.wlan_notification_acm_disconnected:
                        Task.Run(() => tcs.SetResult(true));
                        break;
                    }
                };

                Base.RegisterNotification(client.Handle, WLAN_NOTIFICATION_SOURCE_ACM, callback);

                var result = Base.Disconnect(client.Handle, interfaceId);
                if (!result)
                {
                    tcs.SetResult(false);
                }

                var disconnectTask = tcs.Task;
                var completedTask  = await Task.WhenAny(disconnectTask, Task.Delay(timeout, cancellationToken));

                return((completedTask == disconnectTask) && disconnectTask.Result);
            }
        }