Telegram.Bot

https://telegrambots.github.io/book
Admin
Telegram.Bot is the most popular .NET client for the Telegram Bot API, allowing developers to build...
Tokens:37,030
Snippets:569
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Run Interactive Bot

Source: https://telegrambots.github.io/book/print.html

Command to start the interactive bot.

```bash
dotnet run
```

--------------------------------

### Telegram.Bot Usage Examples

Source: https://telegrambots.github.io/book/print.html

Demonstrates simplified object construction and method calls using implicit conversions and tuple support.

```csharp
await bot.RestrictChatMember(chatId, userId, new ChatPermissions(true)); // unmute
await bot.SetMessageReaction(msg.Chat, msg.Id, ["👍"]);
await bot.SendMessage(msg.Chat, "Visit t.me/tgbot_net", replyParameters: msg, linkPreviewOptions: true);
await bot.SendInvoice(chatId, "Product", "Description", "ProductID", "XTR", [("Price", 500)]);
await Bot.SetMyCommands([("/start", "Start the bot"), ("/privacy", "Privacy policy")], BotCommandScope.AllPrivateChats());
await bot.SendPhoto(msg.Chat, "https://picsum.photos/310/200.jpg");
await bot.SendVideo(msg.Chat, msg.Video, "Sending your video back");
await bot.SendPoll(chatId, "question", ["answer1", "answer2"]);
```

--------------------------------

### Define Inline Query Data Sources

Source: https://telegrambots.github.io/book/print.html

Example arrays used to populate inline query results.

```csharp
private readonly string[] sites = { "Google", "Github", "Telegram", "Wikipedia" };
private readonly string[] siteDescriptions =
{
    "Google is a search engine",
    "Github is a git repository hosting",
    "Telegram is a messenger",
    "Wikipedia is an open wiki"
};
```

--------------------------------

### Get File Info and Download Separately

Source: https://telegrambots.github.io/book/migrate/Version-14.x.html

This approach first retrieves file information using GetFileAsync and then downloads the file content using DownloadFileAsync. This separates the two steps of file retrieval.

```csharp
// New version of GetFileAsync() only gets the file info (step 1)
File fileInfo = await bot.GetFileAsync("BsdfgLg4Khdlsn-bldBD");

// Download file from server (step 2)
using (var fileStream = System.IO.File.OpenWrite("path/to/file.pdf")) {
    await bot.DownloadFileAsync(
        filePath: fileInfo.FilePath,
        destination: fileStream
    );
}
```

--------------------------------

### Bot Token Format

Source: https://telegrambots.github.io/book/print.html

Example of the format for a Telegram bot token.

```text
1234567:4TT8bAc8GHUspu3ERYn-KGcvsvGB9u_n4ddy
```

--------------------------------

### Example output of message inspection

Source: https://telegrambots.github.io/book/print.html

Sample console output showing the properties of a sent message.

```text
Awesome bot sent message 123 to chat 123456789 at 8/21/18 11:25:09 AM. It is a reply to message 122 and has 2 message entities.
```

--------------------------------

### Download File Info and Content with GetInfoAndDownloadFileAsync

Source: https://telegrambots.github.io/book/migrate/Version-14.x.html

This method combines getting file information and downloading the file content in a single operation. It sends two HTTP requests to the Bot API.

```csharp
// Gets file info and saves it to "path/to/file.pdf"
using (var fileStream = System.IO.File.OpenWrite("path/to/file.pdf"))
{
    File fileInfo = await bot.GetInfoAndDownloadFileAsync(
        fileId: "BsdfgLg4Khdlsn-bldBD",
        destination: fileStream
    );
}
```

--------------------------------

### Use Tor Proxy with TelegramBotClient

Source: https://telegrambots.github.io/book/print.html

Example of connecting the bot through a local Tor SOCKS5 proxy.

```csharp
// using System.Net;
// using System.Net.Http;

WebProxy proxy = new ("socks5://127.0.0.1:9050");

HttpClient httpClient = new (
    new SocketsHttpHandler { Proxy = proxy, UseProxy = true }
);

var bot = new TelegramBotClient("YOUR_API_TOKEN", httpClient);
```

--------------------------------

### Configure SOCKS5 Proxy over Tor for Telegram Bot Client (Testing Only)

Source: https://telegrambots.github.io/book/4/proxy.html

Set up a SOCKS5 proxy connection through the Tor network for testing purposes. This configuration requires Tor Browser to be installed and running, and the bot will only function while Tor is active.

```csharp
// using System.Net;
// using System.Net.Http;

WebProxy proxy = new ("socks5://127.0.0.1:9050");

HttpClient httpClient = new (
    new SocketsHttpHandler { Proxy = proxy, UseProxy = true }
);

var bot = new TelegramBotClient("YOUR_API_TOKEN", httpClient);

```

--------------------------------

### Message Received Console Output

Source: https://telegrambots.github.io/book/print.html

Example console output when the bot receives a message.

```text
Received Message 'test' in Private chat with @You (123456789).
```

--------------------------------

### Constructor Initialization for InlineKeyboardMarkup

Source: https://telegrambots.github.io/book/migrate/Version-14.x.html

Demonstrates the recommended way to initialize InlineKeyboardMarkup with required parameters in the constructor, contrasting it with the older property-based assignment.

```csharp
//bad way:
var markup = new InlineKeyboardMarkup
    {
        Keyboard = buttonsArray,
        ResizeKeyboard = true
    };

// better:
var markup = new InlineKeyboardMarkup(buttonsArray)
    {
        ResizeKeyboard = true
    };
```

--------------------------------

### Initialize ReplyKeyboardMarkup with Object Initializer

Source: https://telegrambots.github.io/book/print.html

Use object initialization syntax to configure optional keyboard properties like ResizeKeyboard.

```csharp
var replyKeyboardMarkup = new ReplyKeyboardMarkup(
    new KeyboardButton[][]
    {
        new KeyboardButton[] { "1.1", "1.2" },
        new KeyboardButton[] { "2.1", "2.2" },
    })
    {
        ResizeKeyboard = true
    };
```

--------------------------------

### Initialize .NET Console Project

Source: https://telegrambots.github.io/book/print.html

Commands to create a new console application and add the Telegram.Bot package dependency.

```bash
dotnet new console
dotnet add package Telegram.Bot
```

--------------------------------

### Dynamic Keyboard Construction

Source: https://telegrambots.github.io/book/print.html

Demonstrates using ReplyKeyboardMarkup and InlineKeyboardMarkup classes to build keyboards dynamically.

```APIDOC
## Dynamic Keyboard Construction

### Description
Use `ReplyKeyboardMarkup` and `InlineKeyboardMarkup` classes to build complex keyboards using fluent methods like `AddButton`, `AddNewRow`, and `AddButtons`.

### Usage Example
```csharp
var replyMarkup = new InlineKeyboardMarkup()
    .AddButton(new InlineKeyboardButton("Link to Repository", "https://github.com/TelegramBots/Telegram.Bot"))
    .AddNewRow().AddButton("callback").AddButton("caption", "data")
    .AddNewRow("with", "three", "buttons")
    .AddNewRow().AddButtons("A", "B", new("switch", InlineButtonType.SwitchInlineQueryCurrentChat));
```
```

--------------------------------

### Configuring ReplyKeyboardMarkup with Optional Properties

Source: https://telegrambots.github.io/book/migrate/Version-17.x.html

When ResizeKeyboard and OneTimeKeyboard are optional, they must be configured using object initialization syntax after creating the ReplyKeyboardMarkup instance.

```csharp
var replyKeyboardMarkup = new ReplyKeyboardMarkup(
    new KeyboardButton[][] 
    {
        new KeyboardButton[] { "1.1", "1.2" },
        new KeyboardButton[] { "2.1", "2.2" },
    })
    {
        ResizeKeyboard = true
    };
```

--------------------------------

### Run Program and Output

Source: https://telegrambots.github.io/book/print.html

Command to execute the bot and the expected console output.

```bash
dotnet run

Hello, World! I am user 1234567 and my name is Awesome Bot.
```

--------------------------------

### Create InlineQueryResultDocument

Source: https://telegrambots.github.io/book/print.html

Demonstrates the recommended way to instantiate an InlineQueryResultDocument.

```csharp
// good way
var documentResult = new InlineQueryResultDocument(
    id: "some-id",
    documentUrl: "https://example.com/document.pdf",
    title: "Some title",
    mimeType: "application/pdf"
);
```

--------------------------------

### Tor Browser 'torcc' Configuration for SOCKS Proxy

Source: https://telegrambots.github.io/book/4/proxy.html

Configure the 'torcc' file in Tor Browser to enable a SOCKS port for proxying. This example sets specific entry and exit nodes and enables the SOCKS port on localhost.

```plaintext
EntryNodes {NL}
ExitNodes {NL}
StrictNodes 1
SocksPort 127.0.0.1:9050

```

--------------------------------

### Constructing Keyboards via replyMarkup

Source: https://telegrambots.github.io/book/print.html

Demonstrates how to pass various types of objects to the replyMarkup parameter when sending messages.

```APIDOC
## Keyboard Construction via replyMarkup

### Description
Keyboards can be constructed by passing specific types to the `replyMarkup` parameter in `SendMessage` calls. Supported types include strings, arrays of strings, `KeyboardButton` objects, and `InlineKeyboardButton` objects.

### Usage Examples
```csharp
// Sending an inline button with URL
await bot.SendMessage(msg.Chat, "Visit our website", replyMarkup: ("Click here", "https://telegrambots.github.io/book/", KeyboardButtonStyle.Success, "5447410659077661506"));

// Sending multiple inline buttons
await bot.SendMessage(botOwnerId, $"Annoying user: {msg.From}", replyMarkup: new InlineKeyboardButton[]
    { ("Ban him", $"BAN {msg.From.Id}", KeyboardButtonStyle.Danger), ("Mute him", $"MUTE {msg.From.Id}") });

// Sending simple text buttons
await bot.SendMessage(msg.Chat, "Keyboard buttons:", replyMarkup: new string[] { "MENU", "INFO", "LANGUAGE" });
```
```

--------------------------------

### Instantiate TelegramBotClient with Token

Source: https://telegrambots.github.io/book/migrate/Version-18.x.html

Create a TelegramBotClient instance using only the bot token when no additional configuration is needed.

```csharp
var client = new TelegramBotClient("<token>");
```

--------------------------------

### Configure TelegramBotClient with Options

Source: https://telegrambots.github.io/book/migrate/Version-18.x.html

Instantiate TelegramBotClient with custom options, including a base URL for a custom bot server or to enable the test environment.

```csharp
using Telegram.Bot;

var options = new TelegramBotClientOptions(
    token: "<token>"

    // pass an optional baseUrl if you want to use a custom bot server
    baseUrl: "https://custombotserverdomain.com",

    // pass an optional flag `true` if you want to use test environment
    useTestEnvironment = true
);

var client = new TelegramBotClient(options);
```

--------------------------------

### Construct BotCommand from tuple

Source: https://telegrambots.github.io/book/migrate/Version-22.x.html

Implicitly construct BotCommand objects using a tuple of command and description.

```csharp
await Bot.SetMyCommands([("/start", "Start the bot"), ("/privacy", "Privacy policy")]);
```

--------------------------------

### Upload a local file using a stream

Source: https://telegrambots.github.io/book/print.html

Opens a file stream from the local machine to send as a document. Ensure the file path is correct and the bot has necessary permissions.

```csharp
await using var stream = File.OpenRead("../hamlet.pdf");
var message = await bot.SendDocument(chatId, stream, "The Tragedy of Hamlet,\nPrince of Denmark");
```

--------------------------------

### Create Keyboard Buttons with Factory Methods

Source: https://telegrambots.github.io/book/print.html

Use factory methods on KeyboardButton and InlineKeyboardButton classes for cleaner keyboard configuration.

```csharp
// Message having an inline keyboard button with URL that redirects to a page
await bot.SendTextMessageAsync(
    chatId: -9876,
    text: "Check out the source code",
    replyMarkup: new InlineKeyboardMarkup(
        InlineKeyboardButton.WithUrl("Repository", "https://github.com/TelegramBots/Telegram.Bot")
    )
);
```

```csharp
// Message to a private chat having a 2-row reply keyboard
await bot.SendTextMessageAsync(
    chatId: 1234,
    text: "Share your contact & location",
    replyMarkup: new ReplyKeyboardMarkup(
        new [] { KeyboardButton.WithRequestContact("Share Contact") },
        new [] { KeyboardButton.WithRequestLocation("Share Location") },
    )
);
```

--------------------------------

### Configure Webhook URL

Source: https://telegrambots.github.io/book/print.html

Initialize the TelegramBotClient and register the public URL where Telegram should send updates.

```csharp
var bot = new TelegramBotClient("YOUR_BOT_TOKEN");
await bot.SetWebhook("https://your.public.host:port/bot", allowedUpdates: []);
```

--------------------------------

### Download File using Helper Method

Source: https://telegrambots.github.io/book/print.html

Uses the library helper function to perform both file information retrieval and download in a single call.

```csharp
await using var ms = new MemoryStream();
var tgFile = await bot.GetInfoAndDownloadFile(fileId, ms);
```

--------------------------------

### Implement Interactive Message Handling

Source: https://telegrambots.github.io/book/print.html

Sets up a bot that listens for messages and echoes them back to the user.

```csharp
using Telegram.Bot;
using Telegram.Bot.Types;
using Telegram.Bot.Types.Enums;

using var cts = new CancellationTokenSource();
var bot = new TelegramBotClient("YOUR_BOT_TOKEN", cancellationToken: cts.Token);
var me = await bot.GetMe();
bot.OnMessage += OnMessage;

Console.WriteLine($"@{me.Username} is running... Press Enter to terminate");
Console.ReadLine();
cts.Cancel(); // stop the bot

// method that handle messages received by the bot:
async Task OnMessage(Message msg, UpdateType type)
{
    if (msg.Text is null) return;	// we only handle Text messages here
    Console.WriteLine($"Received {type} '{msg.Text}' in {msg.Chat}");
    // let's echo back received text in the chat
    await bot.SendMessage(msg.Chat, $"{msg.From} said: {msg.Text}");
}
```

--------------------------------

### Configure Telegram Bot with Event Handlers

Source: https://telegrambots.github.io/book/print.html

Sets up a bot client with OnMessage, OnUpdate, and OnError event handlers to manage interactions and exceptions.

```csharp
using Telegram.Bot;
using Telegram.Bot.Polling;
using Telegram.Bot.Types;
using Telegram.Bot.Types.Enums;
using Telegram.Bot.Types.ReplyMarkups;

using var cts = new CancellationTokenSource();
var bot = new TelegramBotClient("YOUR_BOT_TOKEN", cancellationToken: cts.Token);
var me = await bot.GetMe();
bot.OnError += OnError;
bot.OnMessage += OnMessage;
bot.OnUpdate += OnUpdate;

Console.WriteLine($"@{me.Username} is running... Press Enter to terminate");
Console.ReadLine();
cts.Cancel(); // stop the bot

// method to handle errors in polling or in your OnMessage/OnUpdate code
async Task OnError(Exception exception, HandleErrorSource source)
{
    Console.WriteLine(exception); // just dump the exception to the console
}

// method that handle messages received by the bot:
async Task OnMessage(Message msg, UpdateType type)
{
    if (msg.Text == "/start")
    {
        await bot.SendMessage(msg.Chat, "Welcome! Pick one direction",
            replyMarkup: new InlineKeyboardButton[] { "Left", "Right" });
    }
}

// method that handle other types of updates received by the bot:
async Task OnUpdate(Update update)
{
    if (update is { CallbackQuery: { } query }) // non-null CallbackQuery
    {
        await bot.AnswerCallbackQuery(query.Id, $"You picked {query.Data}");
        await bot.SendMessage(query.Message!.Chat, $"User {query.From} clicked on {query.Data}");
    }
}
```

--------------------------------

### Upload Video from Disk

Source: https://telegrambots.github.io/book/print.html

Sends a video file by opening a local file stream.

```csharp
await using Stream stream = File.OpenRead("./video-hawk.mp4");
await bot.SendVideo(chatId, stream);
```

--------------------------------

### Instantiate InlineQueryResultDocument using Constructor

Source: https://telegrambots.github.io/book/migrate/Version-14.x.html

Use the constructor with required properties to instantiate InlineQueryResultDocument. This is the preferred and safer way compared to object initialization, reducing the risk of exceptions.

```csharp
// good way
var documentResult = new InlineQueryResultDocument(
    id: "some-id",
    documentUrl: "https://example.com/document.pdf",
    title: "Some title",
    mimeType: "application/pdf"
);
```

--------------------------------

### Create InlineKeyboardButton with LoginUrl

Source: https://telegrambots.github.io/book/4/index.html

Use this to create an inline button that initiates a login connection to your website using Telegram user credentials. Ensure your website domain is associated with your bot via @BotFather.

```csharp
replyMarkup: InlineKeyboardButton.WithLoginUrl("login",
                 new LoginUrl { Url = "https://yourdomain.com/url" })
```

--------------------------------

### Fetch Bot Information

Source: https://telegrambots.github.io/book/print.html

Basic implementation to verify bot token by calling the getMe method.

```csharp
using Telegram.Bot;

var bot = new TelegramBotClient("YOUR_BOT_TOKEN");
var me = await bot.GetMe();
Console.WriteLine($"Hello, World! I am user {me.Id} and my name is {me.FirstName}.");
```

--------------------------------

### Create a reply keyboard with request buttons

Source: https://telegrambots.github.io/book/print.html

Sends a message with buttons that request specific user information like location or contact details.

```csharp
// using Telegram.Bot.Types.ReplyMarkups;

var sent = await bot.SendMessage(chatId, "Who or Where are you?", replyMarkup: new KeyboardButton[]
{
    new("Share Location", requestLocation: true),
    new("Share Contact", requestContact: true)
});
```

--------------------------------

### Send messages with keyboards

Source: https://telegrambots.github.io/book/print.html

Demonstrates sending messages with inline and reply keyboards using tuples and arrays.

```csharp
await bot.SendMessage(msg.Chat, "Visit our website", replyMarkup: ("Click here", "https://telegrambots.github.io/book/", KeyboardButtonStyle.Success, "5447410659077661506"));
await bot.SendMessage(botOwnerId, $"Annoying user: {msg.From}", replyMarkup: new InlineKeyboardButton[]
    { ("Ban him", $"BAN {msg.From.Id}", KeyboardButtonStyle.Danger), ("Mute him", $"MUTE {msg.From.Id}") });
await bot.SendMessage(msg.Chat, "Keyboard buttons:", replyMarkup: new string[] { "MENU", "INFO", "LANGUAGE" });
```

--------------------------------

### Answer Shipping Query with Options

Source: https://telegrambots.github.io/book/4/payments.html

Respond to a ShippingQuery for physical goods by providing available shipping options. Each option can include multiple price lines for packaging and shipping.

```csharp
var shippingOptions = new List<ShippingOption>();
shippingOptions.Add(new() { Title = "DHL Express", Id = "dhl-express",
    Prices = [("Shipping", 1200)] });
shippingOptions.Add(new() { Title = "FedEx Fragile", Id = "fedex-fragile",
    Prices = [("Packaging", 500), ("Shipping", 1800)] });
await bot.AnswerShippingQuery(shippingQuery.Id, shippingOptions);
```

--------------------------------

### Configure Link Previews with HTML

Source: https://telegrambots.github.io/book/print.html

Use the <preview> tag to disable previews or force specific URLs. The tag must be placed after the message text and only when no media is specified.

```csharp
var msg = await bot.SendHtml(chatId, """
    no preview: https://github.com/TelegramBots/Telegram.Bot.Examples
    <preview disabled>
    """);

var msg2 = await bot.SendHtml(chatId, """
    Preview URL is not even in message text
    <preview url="https://github.com/TelegramBots/Telegram.Bot.Examples" small above>
    """);
```

--------------------------------

### Create Callback Buttons

Source: https://telegrambots.github.io/book/print.html

Constructs an inline keyboard with callback buttons using tuples of (title, callbackData).

```csharp
// using Telegram.Bot.Types.ReplyMarkups;

var sent = await bot.SendMessage(chatId, "A message with an inline keyboard markup",
    replyMarkup: new InlineKeyboardButton[][]
    {
        [("1.1", "11"), ("1.2", "12")], // two buttons on first row
        [("2.1", "21"), ("2.2", "22")]  // two buttons on second row
    });
```

--------------------------------

### Send media from streams

Source: https://telegrambots.github.io/book/print.html

Sends media by passing a list of streams and referencing them in the HTML using stream://N or filename syntax.

```csharp
await using var stream0 = File.OpenRead(@"C:\Pictures\banner.png");
await using var stream1 = File.OpenRead(@"C:\Pictures\image.jpg");
var msg = await bot.SendHtml(chatId, """
    <img src="image.jpg">
    <img src="stream://0">
    """, streams: [stream0, stream1]);
```

--------------------------------

### Download Files with GetInfoAndDownloadFileAsync

Source: https://telegrambots.github.io/book/print.html

Use GetInfoAndDownloadFileAsync to perform both file info retrieval and download in a single operation.

```csharp
// Gets file info and saves it to "path/to/file.pdf"
using (var fileStream = System.IO.File.OpenWrite("path/to/file.pdf"))
{
    File fileInfo = await bot.GetInfoAndDownloadFileAsync(
        fileId: "BsdfgLg4Khdlsn-bldBD",
        destination: fileStream
    );
}
```

--------------------------------

### Create URL Buttons

Source: https://telegrambots.github.io/book/print.html

Creates a button that opens an external URL when pressed.

```csharp
// using Telegram.Bot.Types.ReplyMarkups;

var sent = await bot.SendMessage(chatId, "A message with an inline keyboard markup",
        replyMarkup: new InlineKeyboardButton("Repository Link", "https://github.com/TelegramBots/Telegram.Bot"));
```

--------------------------------

### Create Switch to Inline Buttons

Source: https://telegrambots.github.io/book/print.html

Creates buttons that prompt the user to select a chat and insert the bot's username into the input field.

```csharp
// using Telegram.Bot.Types.ReplyMarkups;

var sent = await bot.SendMessage(chatId, "A message with an inline keyboard markup",
    replyMarkup: new InlineKeyboardButton[]
    {
        new("switch_inline_query", InlineButtonType.SwitchInlineQuery),
        new("switch_inline_query_current_chat", InlineButtonType.SwitchInlineQueryCurrentChat)
    });
```

--------------------------------

### Instantiate InlineQueryResult with Constructors

Source: https://telegrambots.github.io/book/print.html

Use constructors with required parameters instead of object initializers to instantiate inline query results.

```csharp
// bad way. easy to get exceptions
var documentResult = new InlineQueryResultDocument
{
    Id = "some-id",
    Url = "https://example.com/document.pdf",
    Title = "Some title",
    MimeType = "application/pdf"
};
```

--------------------------------

### Send Photos with Implicit Casting

Source: https://telegrambots.github.io/book/print.html

Shows how to send photos using either a file stream or a file ID via implicit casting.

```csharp
Stream stream = System.IO.File.OpenRead("photo.png");
var message = await bot.SendPhotoAsync("chat id", stream);

string fileId = "file_id on Telegram servers";
var message = await bot.SendPhotoAsync("chat id", fileId);
```

--------------------------------

### Configure Telegram Bot MVC in ASP.NET Core

Source: https://telegrambots.github.io/book/print.html

Registers the Telegram Bot MVC services in the application startup configuration.

```csharp
services.ConfigureTelegramBotMvc();
```

```csharp
services.ConfigureTelegramBot<Microsoft.AspNetCore.Mvc.JsonOptions>(opt => opt.JsonSerializerOptions);
```

--------------------------------

### Create Inline Keyboard with Styled Buttons

Source: https://telegrambots.github.io/book/print.html

Use the style attribute to set button colors to danger, success, or primary.

```csharp
var msg = await bot.SendHtml(chatId, """
    <img src="https://telegrambots.github.io/book/docs/photo-ara.jpg">
    Do you like this photo?
    <keyboard>
    <button text="Yes" callback="ara-yes" style="success">
    <button text="No" callback="ara-no" style="danger">
    </keyboard>
    """);
```

--------------------------------

### Implement OnInlineQueryReceived

Source: https://telegrambots.github.io/book/print.html

Processes incoming inline queries by generating a list of InlineQueryResultArticle objects and sending them via AnswerInlineQuery.

```csharp
async Task OnInlineQueryReceived(ITelegramBotClient bot, InlineQuery inlineQuery)
{
    var results = new List<InlineQueryResult>();

    var counter = 0;
    foreach (var site in sites)
    {
        results.Add(new InlineQueryResultArticle(
            $"{counter}", // we use the counter as an id for inline query results
            site, // inline query result title
            new InputTextMessageContent(siteDescriptions[counter])) // content that is submitted when the inline query result title is clicked
        );
        counter++;
    }

    await bot.AnswerInlineQuery(inlineQuery.Id, results); // answer by sending the inline query result list
}
```

--------------------------------

### Send Video with Thumbnail and Streaming

Source: https://telegrambots.github.io/book/print.html

Sends a video from a URL with a custom thumbnail and enables streaming support for better playback performance.

```csharp
await bot.SendVideo(chatId, "https://telegrambots.github.io/book/docs/video-countdown.mp4",
    thumbnail: "https://telegrambots.github.io/book/2/docs/thumb-clock.jpg", supportsStreaming: true);
```

--------------------------------

### Create Authorization Request Parameters

Source: https://telegrambots.github.io/book/print.html

Initializes the parameters required to request specific passport data scopes from a user.

```csharp
AuthorizationRequestParameters authReq = new AuthorizationRequestParameters(
    botId: 123456, // bot user ID
    publicKey: "...", // public key in PEM format. same as the key above.
    nonce: "unique nonce for this request",
    scope: new PassportScope { // a PassportScope object
        Data = [
            new PassportScopeElementOne(EncryptedPassportElementType.Address),
            new PassportScopeElementOne(EncryptedPassportElementType.PhoneNumber)
        ]
    });
```

--------------------------------

### Building Inline Keyboards Dynamically

Source: https://telegrambots.github.io/book/migrate/Version-21.x.html

Use InlineKeyboardMarkup methods like AddButton, NewRow, and AddButtons to construct complex inline keyboards programmatically. Supports various button types including URLs and callback data.

```csharp
var replyMarkup = new InlineKeyboardMarkup()
    .AddButton(InlineKeyboardButton.WithUrl("Link to Repository", "https://github.com/TelegramBots/Telegram.Bot"))
    .AddNewRow().AddButton("callback").AddButton("caption", "data")
    .AddNewRow("with", "three", "buttons")
    .AddNewRow().AddButtons("A", "B", InlineKeyboardButton.WithSwitchInlineQueryCurrentChat("switch"));
```

--------------------------------

### Send a video note

Source: https://telegrambots.github.io/book/print.html

Sends a video note as a file stream. Note that sending video notes via URL is not supported, and the length parameter defines both width and height.

```csharp
await using Stream stream = File.OpenRead("path/to/video-waves.mp4");
await bot.SendVideoNote(chatId, stream, duration: 47, length: 360); // length = width = height
```

--------------------------------

### Send Stickers via URL and FileId

Source: https://telegrambots.github.io/book/print.html

Sends a sticker using a direct URL and subsequently reuses the FileId from the first message to send the same sticker again.

```csharp
var message1 = await bot.SendSticker(chatId, "https://telegrambots.github.io/book/docs/sticker-fred.webp");
var message2 = await bot.SendSticker(chatId, message1.Sticker!.FileId);
```

--------------------------------

### Download File via Telegram Bot API

Source: https://telegrambots.github.io/book/print.html

Demonstrates the two-step process of retrieving file information and downloading the file content to a local stream.

```csharp
var fileId = update.Message.Video.FileId;
var tgFile = await bot.GetFile(fileId);

await using var stream = File.Create("../downloaded.mp4");
await bot.DownloadFile(tgFile, stream);
```

--------------------------------

### Create New Chat Invite Link

Source: https://telegrambots.github.io/book/print.html

Generates a new invite link on demand with a specified name or reason.

```csharp
__
var link = await bot.CreateChatInviteLink(chatId, "name/reason", ...);
Console.WriteLine(link.InviteLink);
```

--------------------------------

### Answer Pre-Checkout Query

Source: https://telegrambots.github.io/book/4/payments.html

Confirm or reject a pre-checkout query. Reply with success or an error message within 10 seconds to proceed with the payment.

```csharp
if (confirm)
    await bot.AnswerPreCheckoutQuery(preCheckoutQuery.Id); // success
else
    await bot.AnswerPreCheckoutQuery(preCheckoutQuery.Id, "Can't process your order: <REASON>");
```

--------------------------------

### Handle Updates in ASP.NET Core Minimal APIs

Source: https://telegrambots.github.io/book/print.html

Map a POST endpoint to a handler function to process incoming updates in a Minimal API project.

```csharp
app.MapPost("/bot", (Update update) => HandleUpdate(update));
...

async Task HandleUpdate(Update update)
{
    // put your code to handle one Update here.
}
```

--------------------------------

### Download and decrypt passport file with manual stream control

Source: https://telegrambots.github.io/book/print.html

Splits the process into separate download and decryption steps using memory streams for more granular control.

```csharp
File encryptedFileInfo;
using (System.IO.Stream
    encryptedContent = new System.IO.MemoryStream(element.ReverseSide.FileSize),
    decryptedFile = System.IO.File.OpenWrite("/path/to/reverse-side.jpg")
) {
    // fetch the encrypted file info and download it to memory
    encryptedFileInfo = await bot.GetInfoAndDownloadFile(
        element.ReverseSide.FileId, // file_id of passport file for reverse side
        encryptedContent // stream to copy the encrypted file into
    );
    // ensure memory stream is at the beginning before reading from it
    encryptedContent.Position = 0;

    // decrypt the file and write it to disk
    await decrypter.DecryptFileAsync(
        encryptedContent,
        credentials.SecureData.DriverLicense.ReverseSide, // reverse side FileCredentials
        decryptedFile // destination stream for writing the JPEG content to
    );
}
```

--------------------------------

### Upload a file using MemoryStream

Source: https://telegrambots.github.io/book/print.html

Sends a file from a memory buffer by wrapping it in an InputFile object. Useful when the file data is already loaded into memory.

```csharp
var buffer = File.ReadAllBytes("../hamlet.pdf");
await using var ms = new MemoryStream(buffer);
var message = await bot.SendDocument(chatId, InputFile.FromStream(ms, "Tragedy.pdf"),
                                     "The Tragedy of Hamlet,\nPrince of Denmark");
```

--------------------------------

### Construct Inline Buttons with Styles

Source: https://telegrambots.github.io/book/print.html

Create buttons with specific visual styles using the Style property.

```csharp
new InlineKeyboardButton("Green button", "dataOrUrl") { Style = KeyboardButtonStyle.Success }
```

--------------------------------

### Create Inline Keyboard with URL Button

Source: https://telegrambots.github.io/book/print.html

Define an inline keyboard using the <keyboard> tag. The section must be placed at the end of the message.

```csharp
var msg = await bot.SendHtml(chatId, """
    Simple message <u>with a button</u>
    <keyboard>
    <button text="URL button" url="example.com" icon="4987927696177628011">
    </keyboard>
    """);
```

--------------------------------

### Download and Decrypt Passport File (Reverse Side) in Two Steps

Source: https://telegrambots.github.io/book/4/passport/files-docs.html

Downloads and decrypts the reverse side of a passport file in two distinct operations: first fetching and downloading to memory, then decrypting to a file stream. This provides more control than the single-step method.

```csharp
File encryptedFileInfo;
using (System.IO.Stream
    encryptedContent = new System.IO.MemoryStream(element.ReverseSide.FileSize),
    decryptedFile = System.IO.File.OpenWrite("/path/to/reverse-side.jpg")
) {
    // fetch the encrypted file info and download it to memory
    encryptedFileInfo = await bot.GetInfoAndDownloadFile(
        element.ReverseSide.FileId, // file_id of passport file for reverse side
        encryptedContent // stream to copy the encrypted file into
    );
    // ensure memory stream is at the beginning before reading from it
    encryptedContent.Position = 0;

    // decrypt the file and write it to disk
    await decrypter.DecryptFileAsync(
        encryptedContent,
        credentials.SecureData.DriverLicense.ReverseSide, // reverse side FileCredentials
        decryptedFile // destination stream for writing the JPEG content to
    );
}
```

--------------------------------

### Handle Unknown MessageEntity Types in C#

Source: https://telegrambots.github.io/book/migrate/Version-17.x.html

Illustrates how to use a default case in a switch statement to handle unknown or new MessageEntityType values received from the Telegram Bot API.

```csharp
MessageEntity entity = message.Entities.First();

switch (entity.Type)
{
    case MessageEntityType.Username:
        // ...
        break;
    case MessageEntityType.Command:
        // ...
        break;
    default:
        // All unknown values will go there
        break;
}
```

--------------------------------

### Handle Telegram Bot API Exceptions in C#

Source: https://telegrambots.github.io/book/migrate/Version-17.x.html

Demonstrates how to catch and handle various exceptions like ApiRequestException, RequestException, and OperationCancelledException. It includes specific cases for status codes and inner exception types.

```csharp
try
{
    await bot.SendTextMessageAsync(chatId, "Hello");
}
catch (ApiRequestException exception)
{
    switch (exception.StatusCode)
    {
        case 400:
            // Handle incorrect requests exceptions
            break;
        case 401:
            // Handle incorrect bot token exception (revoked tokens)
            break;
        case 403:
            // Handle authorization exceptions (blocked users, unaccessible chats, etc)
            break;
        case 429:
            // Handle rate limiting exception
            break;
        default:
            // Handle other errors with valid json body: it includes status code and description of the error
            break;
    }
}
catch (RequestException exception)
{
    if (exception.InnerException is HttpRequestException httpRequestException)
    {
        // Handle connection exceptions or 5XX exceptions from the Bot API
    }
    else if (exception.InnerException is JsonSerializationException serializationException)
    {
        // Handle serialization exception when a request or a response can't be serialized for some reason
    }
    else
    {
        // Handle all other exceptions
    }
}
catch (OperationCancelledException exception)
{
    // Handle cancellation exception, e.g. when CancellationToken is cancelled
}
```

--------------------------------

### Send a Venue

Source: https://telegrambots.github.io/book/print.html

Sends a venue message requiring latitude, longitude, title, and address parameters.

```csharp
await bot.SendVenue(chatId, latitude: 50.0840172f, longitude: 14.418288f,
    title: "Man Hanging out", address: "Husova, 110 00 Staré Město, Czechia");
```

--------------------------------

### Send a message with advanced parameters

Source: https://telegrambots.github.io/book/print.html

Sends a message using HTML formatting, content protection, and reply parameters.

```csharp
var message = await bot.SendMessage(chatId, "Trying <b>all the parameters</b> of <code>sendMessage</code> method",
    ParseMode.Html,
    protectContent: true,
    replyParameters: update.Message.Id,
    replyMarkup: new InlineKeyboardButton("Check sendMessage method", "https://core.telegram.org/bots/api#sendmessage"));
```
Tokens:
Raw