C# Telegram Bot: Formatting User Messages With Markdown

Sep 4, 2025 by ADMIN 56 views

Hey guys! Let's dive into a cool topic: how to make your C# Telegram bot handle and send messages from users while keeping all that lovely formatting intact. We all know users love to use bold, italics, and even code snippets to make their messages pop. But how do we, as bot developers, make sure these styles survive the journey from the user's chat to the bot and then back to someone else (or even the same user)? It's a classic problem, and the solution often involves embracing the power of Markdown or HTML.

Understanding the Problem and Why Formatting Matters

First off, why should we even care about formatting? Well, imagine you're building a bot that shares news articles, sends programming snippets, or maybe just relays funny stories. Without formatting, everything becomes a wall of plain text. It's hard to read, boring, and the meaning can get lost in the noise. Formatting is crucial for:

Readability: Makes text easier on the eyes.
Emphasis: Highlights important words or phrases.
Structure: Organizes information logically.
User Experience: Keeps users engaged and makes the bot more user-friendly.

So, yeah, formatting is a big deal! Now, how do we preserve it? Telegram bots support Markdown and HTML for formatting messages. Markdown is generally easier to work with, and we'll focus on it here. HTML offers more flexibility, but it can also be more complex to implement and manage.

Markdown: Your Formatting Superhero

Markdown is a lightweight markup language that allows you to format text using simple syntax. For example:

*bold text* becomes bold text
_italic text_ becomes italic text
code becomes code
[link](https://example.com) becomes link

Telegram bots understand a subset of Markdown, so you don't need to implement a full Markdown parser. You just need to know how to escape special characters and use the right syntax.

Building Your Formatting Function in C#

Now, let's look at how to build a function in C# to process messages and preserve formatting. The core idea is to parse the user's message, identify the formatting elements (like bold, italics, code, etc.), and then reconstruct the message with the correct Markdown syntax for Telegram. Here's a basic example to get you started:

using Telegram.Bot;
using Telegram.Bot.Types;
using Telegram.Bot.Types.Enums;
using System.Text;

public class TelegramBotFormatter
{
    public static async Task<string> FormatMessage(ITelegramBotClient botClient, Message message)
    {
        if (message == null || string.IsNullOrEmpty(message.Text))
        {
            return message?.Text ?? string.Empty; // Return original if null or empty
        }

        StringBuilder formattedMessage = new StringBuilder();
        int offset = 0;

        if (message.Entities != null)
        {  // Check for null
            foreach (var entity in message.Entities)
            {
                if (entity.Offset > offset)
                {
                    formattedMessage.Append(message.Text.Substring(offset, entity.Offset - offset));
                }

                switch (entity.Type)
                {
                    case MessageEntityType.Bold:
                        formattedMessage.Append("*");
                        formattedMessage.Append(message.Text.Substring(entity.Offset, entity.Length));
                        formattedMessage.Append("*");
                        break;
                    case MessageEntityType.Italic:
                        formattedMessage.Append("_");
                        formattedMessage.Append(message.Text.Substring(entity.Offset, entity.Length));
                        formattedMessage.Append("_");
                        break;
                    case MessageEntityType.Code:
                        formattedMessage.Append("`");
                        formattedMessage.Append(message.Text.Substring(entity.Offset, entity.Length));
                        formattedMessage.Append("`");
                        break;
                    case MessageEntityType.Pre:
                        formattedMessage.Append("```"); // For code blocks
                        formattedMessage.Append(message.Text.Substring(entity.Offset, entity.Length));
                        formattedMessage.Append("```");
                        break;
                    case MessageEntityType.TextLink:
                        formattedMessage.Append("[");
                        formattedMessage.Append(message.Text.Substring(entity.Offset, entity.Length));
                        formattedMessage.Append("](");
                        formattedMessage.Append(entity.Url);
                        formattedMessage.Append(")");
                        break;
                    case MessageEntityType.TextMention:
                         formattedMessage.Append("[@");
                         formattedMessage.Append(message.Text.Substring(entity.Offset, entity.Length));
                         formattedMessage.Append("](tg://user?id=");
                         formattedMessage.Append(entity.User.Id);
                         formattedMessage.Append(")");
                         break;
                    default:
                        formattedMessage.Append(message.Text.Substring(entity.Offset, entity.Length)); //Handles other types
                        break;
                }
                offset = entity.Offset + entity.Length;
            }
        }

        if (offset < message.Text.Length)
        {
            formattedMessage.Append(message.Text.Substring(offset));
        }

        return formattedMessage.ToString();
    }
}

Explanation: This C# code is designed to format messages from a Telegram bot to preserve the original text formatting provided by the user, such as bold, italics, code blocks, and links. Let's break it down step by step:

Dependencies and Setup:
- The code starts by including the necessary namespaces from the Telegram.Bot library and System.Text for string manipulation.
- It defines a class named TelegramBotFormatter where the formatting logic resides.
FormatMessage Method: This method is the core of the formatting process and takes two parameters:
- ITelegramBotClient botClient: An instance of your Telegram bot client, used for interacting with the Telegram Bot API.
- Message message: The message object received from the user, containing the text and formatting entities.
Null and Empty Checks: The method first checks if the message or its Text property is null or empty. If so, it returns the original text (or an empty string) to avoid errors. This ensures that if there's no text or the message is invalid, the method gracefully handles it.
Initialization:
- StringBuilder formattedMessage = new StringBuilder();: A StringBuilder is used to efficiently construct the formatted message, as it minimizes string concatenation overhead.
- int offset = 0;: An integer offset is initialized to track the current position in the original text as the method processes formatting entities.
Entity Iteration: The code then checks if the message has any entities (formatting elements) using message.Entities != null. If entities exist, it iterates through them.
- Pre-Entity Text: Before processing each entity, the code checks if there's any text between the current offset and the start of the entity. If so, it appends that text to formattedMessage, ensuring that unformatted text is also included.
- Switch Statement: A switch statement is used to handle different types of entities:
  - Bold: Inserts * before and after the formatted text.
  - Italic: Inserts _ before and after the formatted text.
  - Code: Inserts ` before and after the code text.
  - Pre (Code Block): Inserts ``` before and after to indicate code block formatting.
  - TextLink: Formats the link in markdown [text](url)
  - TextMention: Formats the mention [@username](tg://user?id=userid)
  - Default: Handles other entity types by simply appending the original text. This ensures that the code can handle future entity types without modification.
- Update Offset: After processing each entity, the offset is updated to the end of the entity to prepare for the next entity.
Post-Entity Text: After processing all entities, the code checks if there's any remaining text after the last entity. If so, it appends that to formattedMessage.
Return Formatted Message: Finally, the method returns the formatted message as a string. This string contains the original text with the appropriate Markdown formatting applied.

Important Considerations and Edge Cases

Escaping Special Characters: Always escape special Markdown characters if they are not meant to be interpreted as formatting. For example, if you want to display an actual asterisk (\*), you need to escape it: ${}$
Complex Formatting: Nesting formatting (e.g., italic bold) can be tricky and might not always render as expected. Test thoroughly.
Error Handling: Add error handling to gracefully manage unexpected input or API errors.
User Input Validation: Validate user input to prevent potential issues such as malicious code injection (if you're dealing with user-provided URLs or other potentially dangerous content).
Telegram API Updates: Keep an eye on updates to the Telegram Bot API, as formatting rules and entity types might change over time. Make sure your bot and the libraries you use are updated to the latest versions.
Performance: While StringBuilder is generally efficient, for very large messages with many entities, consider optimizing your code further, such as caching the formatted output or using multithreading.

Implementing in Your Bot

To use this in your bot, you'd typically do something like this:

using Telegram.Bot;
using Telegram.Bot.Types;
using Telegram.Bot.Types.Enums;

// Inside your bot's message handling logic:
public async Task HandleUpdateAsync(ITelegramBotClient botClient, Update update, CancellationToken cancellationToken)
{
    if (update.Type == UpdateType.Message && update.Message.Type == MessageType.Text)
    {
        string formattedText = await TelegramBotFormatter.FormatMessage(botClient, update.Message);
        await botClient.SendTextMessageAsync(
            chatId: update.Message.Chat.Id,
            text: formattedText,
            parseMode: ParseMode.MarkdownV2, // or ParseMode.Markdown if using that
            cancellationToken: cancellationToken
        );
    }
}

Here's a breakdown of the code snippet:

HandleUpdateAsync Method: This method is where your bot handles incoming updates from Telegram. It receives the botClient, update (the incoming message), and a cancellationToken.
Update Type and Message Type Checks: The code first checks if the update type is a Message and if the message type is Text. This ensures that you're only processing text messages.
Format the Message:
- string formattedText = await TelegramBotFormatter.FormatMessage(botClient, update.Message);: This line calls the FormatMessage method (we created earlier) to format the user's message, ensuring the formatting is preserved. The botClient and the incoming update.Message are passed as arguments.
Send the Formatted Message:
- await botClient.SendTextMessageAsync(...): The bot then sends the formatted message back to the user using SendTextMessageAsync method.
- chatId: update.Message.Chat.Id: Specifies the chat ID where the message should be sent.
- text: formattedText: Sends the formatted text created by the FormatMessage method.
- parseMode: ParseMode.MarkdownV2: This is crucial! It tells Telegram to parse the text using MarkdownV2 (or Markdown, depending on your needs). MarkdownV2 is generally recommended because it provides stricter escaping rules and better support for modern features. Remember to adjust the parse mode if you change your formatting style.
- cancellationToken: cancellationToken: This provides a way to cancel the operation if needed.

Conclusion

And there you have it! You've got the knowledge to preserve user formatting in your C# Telegram bot. Remember to handle edge cases, test thoroughly, and keep up with the Telegram Bot API updates. Happy coding, and go build some amazing bots!