Can't wait for user input

[wiscount]

In earlier versions (v17) waiting input from user was possible with this method.

 public static async Task<string> WaitForReplyAsync(this TelegramBotClient botClient, long chatId, TimeSpan? timeout = null)
        {
            if (timeout == null)
                timeout = TimeSpan.FromSeconds(30);
            var tcs = new TaskCompletionSource<string>();

            void OnMessageReceived(object sender, MessageEventArgs e)
            {
                if (e.Message.Chat.Id == chatId && e.Message.Type == MessageType.Text)
                {
                    botClient.OnMessage -= OnMessageReceived;
                    tcs.TrySetResult(e.Message.Text);
                    // Remove message from chat
                    GLB.bot.DeleteMessageAsync(chatId, e.Message.MessageId);
                }
            }

            botClient.OnMessage += OnMessageReceived;

            var timeoutTask = Task.Delay(timeout.Value);
            var completedTask = await Task.WhenAny(tcs.Task, timeoutTask);

            if (completedTask == timeoutTask)
            {
                botClient.OnMessage -= OnMessageReceived;
                return null;
            }

            return await tcs.Task;
        }

I also made WaitForKeyboard event that waits for markup event.

  public static async Task<string> WaitForKeyboard(this TelegramBotClient client, long chatId)
        {

            var tcs = new TaskCompletionSource<string>();

            void OnCallbackQueryReceived(object sender, CallbackQueryEventArgs e)
            {
                if (e.CallbackQuery.Message.Chat.Id == chatId)
                {
                    client.OnCallbackQuery -= OnCallbackQueryReceived;
                    tcs.TrySetResult(e.CallbackQuery.Data);
                }
            }

            client.OnCallbackQuery += OnCallbackQueryReceived;

            var timeoutTask = Task.Delay(TimeSpan.FromSeconds(30));
            var completedTask = await Task.WhenAny(tcs.Task, timeoutTask);

            if (completedTask == timeoutTask)
            {
                client.OnCallbackQuery -= OnCallbackQueryReceived;
                return null;
            }

            return await tcs.Task;
        }

It basically binds new handler to OnMessage event and filtering the sender.id to know whether message sent from correct user.

In new versions there are no OnMessage event, the only event we can use is OnApiResponseReceived which is pretty useless and non-sense (useless thing ever) binding extra handler to this event won't work as handler won't contain anything related about message/chat.

[karb0f0s]

I believe that what you described is generally known as a "callback hell". This kind of application logic often results in bugs and leaks due to incorrect use of events.
In general, you should use a state machine pattern to keep track for the conversation.
Alternatively, you can use one of the frameworks, based on Telegram.Bot library.