public async Task TestCancel(int timeout)
        {
            bool executed = false;

            var delayedTask = new DelayedTask(() =>
            {
                executed = true;
                return(Task.CompletedTask);
            }, 500);

            Assert.IsNull(delayedTask.Canceled);

            await Task.Delay(100).ConfigureAwait(false);

            delayedTask.Cancel();

            if (timeout < 0)
            {
                await delayedTask.Task.ConfigureAwait(false);
            }
            else
            {
                await Task.Delay(timeout).ConfigureAwait(false);
            }

            Assert.IsTrue(delayedTask.Canceled ?? false);
            Assert.IsFalse(executed);
        }
        protected override void OnClosing(CancelEventArgs e)
        {
            _saveConfigDelayed.Cancel();
            SaveConfig();

            e.Cancel = true;
            Hide();

            IPDFViewer.CloseDocument();
            IPDFViewer.PDFElement = null;

            base.OnClosing(e);
        }
        public async Task StartSendPriorityMessage(Message message, IClient exclude, long excludeFcmAccountId)
        {
            var sessions = await database.ChannelMembers.AsQueryable()
                           .Where(m => m.ChannelId == message.ChannelId)
                           .Join(database.Sessions, m => m.AccountId, s => s.AccountId, (m, s) => new { s.AccountId, s.SessionId })
                           .OrderBy(s => s.AccountId)
                           .ToArrayAsync().ConfigureAwait(false);

            long        lastAccountId = default;
            DelayedTask lastTimer     = null;

            foreach (var session in sessions)
            {
                if (session.AccountId != lastAccountId)
                {
                    lastAccountId = session.AccountId;
                    lastTimer     = new DelayedTask(() =>
                    {
                        if (session.AccountId != excludeFcmAccountId)
                        {
                            return(notification.SendFcmNotification(session.AccountId));
                        }
                        else
                        {
                            return(Task.CompletedTask);
                        }
                    }, fcmOptions.Value.PriorityMessageAckTimeout);
                }

                // Declare a separate variable that can be safely captured and is not changed with the next iteration
                DelayedTask timer = lastTimer;

                void callback(IClient client, Packet packet)
                {
                    if (packet is P22MessageReceived received && received.Dependencies[0].MessageId == message.MessageId)
                    {
                        timer.Cancel(); // Cancel timer because message has been received
                        client.PacketReceived -= callback;
                    }
                }

                if (connections.TryGet(session.SessionId, out IClient client) && !ReferenceEquals(client, exclude))
                {
                    client.PacketReceived += callback;
                    _ = client.Enqueue(message.ToPacket(packets, client.AccountId));
                }
            }
        }