Telegram бот на C#

dotnet new console -n TelegramBot

dotnet add package Telegram.Bot

dotnet add package Microsoft.Extensions.Hosting
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.Json

{
  "BotConfiguration": {
    "BotToken": "YOUR_BOT_TOKEN_HERE",
    "ApiUrl": "https://api.telegram.org"
  }
}

public class BotConfiguration
{
    public string BotToken { get; set; }
    public string ApiUrl { get; set; }
}

public class Bot
{
    private readonly ITelegramBotClient _botClient;
    
    public Bot(BotConfiguration config)
    {
        _botClient = new TelegramBotClient(config.BotToken);
    }
    
    public async Task StartAsync()
    {
        var me = await _botClient.GetMeAsync();
        Console.WriteLine($"Бот {me.Username} запущен");
    }
}

public class UpdateHandler
{
    private readonly ITelegramBotClient _botClient;
    
    public UpdateHandler(ITelegramBotClient botClient)
    {
        _botClient = botClient;
    }
    
    public async Task HandleUpdateAsync(Update update, CancellationToken cancellationToken)
    {
        if (update.Message is not { } message)
            return;
            
        // Здесь будет логика обработки сообщений
    }
}

var botClient = new TelegramBotClient("YOUR_BOT_TOKEN");

var updateHandler = new UpdateHandler();
var receiverOptions = new ReceiverOptions
{
    AllowedUpdates = new[] { 
        UpdateType.Message,
        UpdateType.CallbackQuery,
        UpdateType.InlineQuery 
    }
};

await botClient.ReceiveAsync(
    updateHandler.HandleUpdateAsync,
    updateHandler.HandleErrorAsync,
    receiverOptions,
    cancellationToken
);

public async Task HandleUpdateAsync(Update update, CancellationToken cancellationToken)
{
    try
    {
        switch (update.Type)
        {
            case UpdateType.Message:
                await HandleMessageAsync(update.Message);
                break;
            case UpdateType.CallbackQuery:
                await HandleCallbackQueryAsync(update.CallbackQuery);
                break;
            case UpdateType.InlineQuery:
                await HandleInlineQueryAsync(update.InlineQuery);
                break;
        }
    }
    catch (Exception ex)
    {
        await HandleErrorAsync(ex);
    }
}

private async Task HandleTextMessage(Message message)
{
    var text = message.Text;
    var chatId = message.Chat.Id;
    
    if (text.StartsWith("/"))
    {
        await HandleCommand(message);
        return;
    }
    
    await ProcessRegularMessage(message);
}

private async Task HandleMediaMessage(Message message)
{
    var fileId = message.Photo?.LastOrDefault()?.FileId
        ?? message.Document?.FileId
        ?? message.Video?.FileId;
        
    if (fileId != null)
    {
        var file = await _botClient.GetFileAsync(fileId);
        await ProcessFile(file);
    }
}

private async Task HandleCallbackQuery(CallbackQuery callbackQuery)
{
    var data = callbackQuery.Data;
    var messageId = callbackQuery.Message.MessageId;
    
    await ProcessCallback(data, messageId);
    await _botClient.AnswerCallbackQueryAsync(callbackQuery.Id);
}

public class UserState
{
    public long ChatId { get; set; }
    public string CurrentState { get; set; }
    public Dictionary<string, object> Context { get; set; }
}
 
public class StateManager
{
    private readonly Dictionary<long, UserState> _userStates;
    
    public void SetState(long chatId, string state)
    {
        if (!_userStates.ContainsKey(chatId))
            _userStates[chatId] = new UserState { ChatId = chatId };
            
        _userStates[chatId].CurrentState = state;
    }
    
    public string GetState(long chatId)
    {
        return _userStates.TryGetValue(chatId, out var state) 
            ? state.CurrentState 
            : "default";
    }
}

var replyKeyboard = new ReplyKeyboardMarkup(
    new[]
    {
        new[] { new KeyboardButton("Опция 1"), new KeyboardButton("Опция 2") },
        new[] { new KeyboardButton("Опция 3"), new KeyboardButton("Опция 4") }
    })
{
    ResizeKeyboard = true
};

var inlineKeyboard = new InlineKeyboardMarkup(
    new[]
    {
        new[]
        {
            InlineKeyboardButton.WithCallbackData("Кнопка 1", "action1"),
            InlineKeyboardButton.WithCallbackData("Кнопка 2", "action2")
        }
    });

public async Task HandleErrorAsync(Exception exception, CancellationToken cancellationToken)
{
    var ErrorMessage = exception switch
    {
        ApiRequestException apiRequestException
            => $"Telegram API Error:\n{apiRequestException.ErrorCode}\n{apiRequestException.Message}",
        
        _ => exception.ToString()
    };
 
    await LogError(ErrorMessage);
    
    if (exception is ApiRequestException apiException && apiException.ErrorCode == 429)
    {
        // Обработка превышения лимита запросов
        await HandleRateLimiting(apiException);
    }
}

public class CommandHandler
{
    private readonly Dictionary<string, Func<Message, Task>> _commands;
    
    public CommandHandler()
    {
        _commands = new Dictionary<string, Func<Message, Task>>
        {
            { "/start", HandleStartCommand },
            { "/help", HandleHelpCommand },
            { "/settings", HandleSettingsCommand }
        };
    }
    
    public async Task HandleCommand(Message message)
    {
        var command = message.Text.Split(' ')[0].ToLower();
        if (_commands.TryGetValue(command, out var handler))
        {
            await handler(message);
        }
    }
}

[AttributeUsage(AttributeTargets.Method)]
public class BotCommandAttribute : Attribute
{
    public string Command { get; }
    public string Description { get; }
    
    public BotCommandAttribute(string command, string description)
    {
        Command = command;
        Description = description;
    }
}
 
public class CommandService
{
    [BotCommand("start", "Начать работу с ботом")]
    public async Task StartCommand(Message message)
    {
        // Логика обработки команды start
    }
    
    [BotCommand("help", "Показать справку")]
    public async Task HelpCommand(Message message)
    {
        // Логика обработки команды help
    }
}

public interface IUpdateMiddleware
{
    Task HandleAsync(Update update, UpdateDelegate next);
}
 
public class LoggingMiddleware : IUpdateMiddleware
{
    public async Task HandleAsync(Update update, UpdateDelegate next)
    {
        Console.WriteLine($"Получено обновление типа: {update.Type}");
        await next(update);
        Console.WriteLine("Обработка завершена");
    }
}
 
public class AuthenticationMiddleware : IUpdateMiddleware
{
    public async Task HandleAsync(Update update, UpdateDelegate next)
    {
        if (IsAuthorized(update))
        {
            await next(update);
        }
        else
        {
            // Отправка сообщения о необходимости авторизации
        }
    }
}

public class ConversationContext
{
    private readonly Dictionary<long, Stack<string>> _contextStack;
    
    public void PushContext(long chatId, string context)
    {
        if (!_contextStack.ContainsKey(chatId))
            _contextStack[chatId] = new Stack<string>();
            
        _contextStack[chatId].Push(context);
    }
    
    public string PopContext(long chatId)
    {
        if (_contextStack.TryGetValue(chatId, out var stack) && stack.Count > 0)
            return stack.Pop();
            
        return null;
    }
    
    public string PeekContext(long chatId)
    {
        if (_contextStack.TryGetValue(chatId, out var stack) && stack.Count > 0)
            return stack.Peek();
            
        return null;
    }
}

public class EchoBot
{
    private readonly ITelegramBotClient _botClient;
    
    public async Task HandleUpdateAsync(Update update, CancellationToken ct)
    {
        if (update.Message?.Text == null)
            return;
            
        var message = update.Message;
        var chatId = message.Chat.Id;
        
        await _botClient.SendTextMessageAsync(
            chatId: chatId,
            text: $"Вы написали: {message.Text}",
            cancellationToken: ct
        );
    }
}

public class WeatherBot
{
    private readonly IWeatherService _weatherService;
    private readonly ITelegramBotClient _botClient;
    
    public async Task HandleWeatherRequest(Message message)
    {
        var location = message.Text;
        var weatherInfo = await _weatherService.GetWeatherAsync(location);
        
        var response = $"Погода в {location}:\n" +
                      $"Температура: {weatherInfo.Temperature}°C\n" +
                      $"Влажность: {weatherInfo.Humidity}%\n" +
                      $"Ветер: {weatherInfo.WindSpeed} м/с";
                      
        await _botClient.SendTextMessageAsync(
            message.Chat.Id,
            response,
            replyMarkup: GetWeatherKeyboard()
        );
    }
}

public class TranslatorBot
{
    private readonly ITranslationService _translationService;
    
    public async Task HandleTranslation(Message message)
    {
        var text = message.Text;
        var keyboard = new InlineKeyboardMarkup(new[]
        {
            new[]
            {
                InlineKeyboardButton.WithCallbackData("EN → RU", $"translate_en_ru_{text}"),
                InlineKeyboardButton.WithCallbackData("RU → EN", $"translate_ru_en_{text}")
            }
        });
        
        await _botClient.SendTextMessageAsync(
            message.Chat.Id,
            "Выберите направление перевода:",
            replyMarkup: keyboard
        );
    }
}

public class ReminderBot
{
    private readonly ISchedulerService _scheduler;
    private readonly IDatabase _database;
    
    public async Task AddReminder(Message message, string time, string text)
    {
        var reminder = new Reminder
        {
            ChatId = message.Chat.Id,
            Time = DateTime.Parse(time),
            Text = text
        };
        
        await _database.SaveReminderAsync(reminder);
        await _scheduler.ScheduleReminderAsync(reminder);
        
        await _botClient.SendTextMessageAsync(
            message.Chat.Id,
            $"Напоминание установлено на {time}"
        );
    }
}

public class TicTacToeBot
{
    private readonly Dictionary<long, GameState> _games = new();
    
    public async Task HandleMove(CallbackQuery query)
    {
        var gameState = _games[query.Message.Chat.Id];
        var position = int.Parse(query.Data.Split('_')[1]);
        
        if (gameState.MakeMove(position))
        {
            var keyboard = GenerateGameBoard(gameState);
            await _botClient.EditMessageReplyMarkupAsync(
                query.Message.Chat.Id,
                query.Message.MessageId,
                keyboard
            );
        }
    }
    
    private InlineKeyboardMarkup GenerateGameBoard(GameState state)
    {
        var buttons = new List<InlineKeyboardButton[]>();
        for (int i = 0; i < 3; i++)
        {
            var row = new InlineKeyboardButton[3];
            for (int j = 0; j < 3; j++)
            {
                var position = i * 3 + j;
                var symbol = state.GetSymbol(position);
                row[j] = InlineKeyboardButton.WithCallbackData(
                    symbol.ToString(),
                    $"move_{position}"
                );
            }
            buttons.Add(row);
        }
        return new InlineKeyboardMarkup(buttons);
    }
}

public class ModerationBot
{
    private readonly IContentFilter _contentFilter;
    
    public async Task HandleNewMessage(Message message)
    {
        if (await _contentFilter.ContainsSpam(message.Text))
        {
            await _botClient.DeleteMessageAsync(
                message.Chat.Id,
                message.MessageId
            );
            
            await _botClient.RestrictChatMemberAsync(
                message.Chat.Id,
                message.From.Id,
                new ChatPermissions { CanSendMessages = false },
                untilDate: DateTime.UtcNow.AddMinutes(30)
            );
            
            await _botClient.SendTextMessageAsync(
                message.Chat.Id,
                $"Пользователь {message.From.FirstName} заблокирован на 30 минут за спам"
            );
        }
    }
}

public class PollBot
{
    private readonly Dictionary<string, Poll> _activePolls = new();
    
    public async Task CreatePoll(Message message)
    {
        var pollOptions = message.Text.Split('\n').Skip(1).ToArray();
        var poll = await _botClient.SendPollAsync(
            chatId: message.Chat.Id,
            question: pollOptions[0],
            options: pollOptions.Skip(1).ToArray(),
            isAnonymous: false,
            allowsMultipleAnswers: false
        );
        
        _activePolls[poll.Poll.Id] = new Poll
        {
            CreatorId = message.From.Id,
            Options = pollOptions
        };
    }
}

public class NewsBot
{
    private readonly INewsService _newsService;
    private readonly ISubscriptionManager _subscriptionManager;
    
    public async Task HandleSubscription(Message message)
    {
        var chatId = message.Chat.Id;
        var categories = await _newsService.GetAvailableCategories();
        
        var keyboard = new InlineKeyboardMarkup(
            categories.Select(c => new[]
            {
                InlineKeyboardButton.WithCallbackData(
                    c.Name,
                    $"subscribe_{c.Id}"
                )
            })
        );
        
        await _botClient.SendTextMessageAsync(
            chatId,
            "Выберите категории новостей:",
            replyMarkup: keyboard
        );
    }
    
    public async Task SendNewsUpdate()
    {
        var subscriptions = await _subscriptionManager.GetAllSubscriptions();
        foreach (var sub in subscriptions)
        {
            var news = await _newsService.GetLatestNews(sub.Categories);
            foreach (var item in news)
            {
                await _botClient.SendTextMessageAsync(
                    sub.ChatId,
                    $"*{item.Title}*\n\n{item.Summary}",
                    parseMode: ParseMode.Markdown
                );
            }
        }
    }
}

public class FileManagerBot
{
    private readonly IFileStorage _storage;
    
    public async Task HandleFileUpload(Message message)
    {
        var file = message.Document;
        if (file != null)
        {
            var fileInfo = await _botClient.GetFileAsync(file.FileId);
            var fileName = file.FileName;
            
            await using var stream = new MemoryStream();
            await _botClient.DownloadFileAsync(fileInfo.FilePath, stream);
            
            var fileUrl = await _storage.UploadFile(stream, fileName);
            
            await _botClient.SendTextMessageAsync(
                message.Chat.Id,
                $"Файл сохранен. Используйте команду /get_{fileName} для доступа"
            );
        }
    }
    
    public async Task HandleFileRequest(Message message)
    {
        var fileName = message.Text.Replace("/get_", "");
        var fileStream = await _storage.GetFile(fileName);
        
        await _botClient.SendDocumentAsync(
            message.Chat.Id,
            new InputFileStream(fileStream, fileName)
        );
    }
}

public class CurrencyBot
{
    private readonly ICurrencyService _currencyService;
    private readonly IMemoryCache _cache;
    
    public async Task HandleConversion(Message message)
    {
        var parts = message.Text.Split(' ');
        if (parts.Length == 4)
        {
            var amount = decimal.Parse(parts[1]);
            var fromCurrency = parts[2].ToUpper();
            var toCurrency = parts[3].ToUpper();
            
            var rate = await GetExchangeRate(fromCurrency, toCurrency);
            var result = amount * rate;
            
            await _botClient.SendTextMessageAsync(
                message.Chat.Id,
                $"{amount} {fromCurrency} = {result:F2} {toCurrency}"
            );
        }
    }
    
    private async Task<decimal> GetExchangeRate(string from, string to)
    {
        var cacheKey = $"{from}_{to}";
        if (!_cache.TryGetValue(cacheKey, out decimal rate))
        {
            rate = await _currencyService.GetExchangeRate(from, to);
            _cache.Set(cacheKey, rate, TimeSpan.FromHours(1));
        }
        return rate;
    }
}

public class ChannelAdminBot
{
    private readonly IContentScheduler _scheduler;
    
    public async Task SchedulePost(Message message)
    {
        var content = message.Text;
        var keyboard = new InlineKeyboardMarkup(new[]
        {
            new[]
            {
                InlineKeyboardButton.WithCallbackData("Опубликовать сейчас", "publish_now"),
                InlineKeyboardButton.WithCallbackData("Запланировать", "schedule")
            }
        });
        
        await _botClient.SendTextMessageAsync(
            message.Chat.Id,
            "Выберите действие:",
            replyMarkup: keyboard
        );
        
        await _scheduler.SaveDraft(message.Chat.Id, content);
    }
    
    public async Task HandleScheduling(CallbackQuery query)
    {
        var content = await _scheduler.GetDraft(query.Message.Chat.Id);
        if (query.Data == "publish_now")
        {
            await _botClient.SendTextMessageAsync(
                "@channel_name",
                content
            );
        }
        else
        {
            // Показать календарь для выбора времени публикации
            await ShowScheduleCalendar(query.Message.Chat.Id);
        }
    }
}

public class MusicBot
{
    private readonly IMusicService _musicService;
    private readonly IAudioProcessor _audioProcessor;
    
    public async Task HandleAudioMessage(Message message)
    {
        var audio = message.Audio;
        if (audio != null)
        {
            var metadata = await _musicService.GetMetadata(audio);
            await _botClient.SendTextMessageAsync(
                message.Chat.Id,
                $"Трек: {metadata.Title}\n" +
                $"Исполнитель: {metadata.Artist}\n" +
                $"Альбом: {metadata.Album}\n" +
                $"Год: {metadata.Year}"
            );
        }
    }
    
    public async Task HandleMusicSearch(Message message)
    {
        var query = message.Text.Replace("/search ", "");
        var results = await _musicService.SearchTracks(query);
        
        var keyboard = new InlineKeyboardMarkup(
            results.Select(r => new[]
            {
                InlineKeyboardButton.WithCallbackData(
                    $"{r.Artist} - {r.Title}",
                    $"play_{r.Id}"
                )
            })
        );
        
        await _botClient.SendTextMessageAsync(
            message.Chat.Id,
            "Найденные треки:",
            replyMarkup: keyboard
        );
    }
}

public class NotesBot
{
    private readonly INotesRepository _repository;
    
    public async Task HandleNewNote(Message message)
    {
        var note = new Note
        {
            UserId = message.From.Id,
            Content = message.Text,
            CreatedAt = DateTime.UtcNow
        };
        
        await _repository.SaveNote(note);
        
        await _botClient.SendTextMessageAsync(
            message.Chat.Id,
            "Заметка сохранена! Используйте /list для просмотра всех заметок"
        );
    }
    
    public async Task ListNotes(Message message)
    {
        var notes = await _repository.GetUserNotes(message.From.Id);
        var notesList = notes.Select((n, i) => 
            $"{i + 1}. {n.Content.Substring(0, Math.Min(50, n.Content.Length))}..."
        );
        
        var response = string.Join("\n", notesList);
        await _botClient.SendTextMessageAsync(
            message.Chat.Id,
            response.Length > 0 ? response : "У вас пока нет заметок"
        );
    }
}

public class CalendarBot
{
    private readonly IEventManager _eventManager;
    
    public async Task AddEvent(Message message)
    {
        var eventData = message.Text.Split('\n');
        var newEvent = new Event
        {
            Title = eventData[0],
            Description = eventData[1],
            DateTime = DateTime.Parse(eventData[2]),
            UserId = message.From.Id
        };
        
        await _eventManager.CreateEvent(newEvent);
        
        var reminderKeyboard = new InlineKeyboardMarkup(new[]
        {
            new[]
            {
                InlineKeyboardButton.WithCallbackData("За 1 час", $"remind_1h_{newEvent.Id}"),
                InlineKeyboardButton.WithCallbackData("За 1 день", $"remind_1d_{newEvent.Id}")
            }
        });
        
        await _botClient.SendTextMessageAsync(
            message.Chat.Id,
            "Событие добавлено! Настроить напоминание?",
            replyMarkup: reminderKeyboard
        );
    }
    
    public async Task ViewCalendar(Message message)
    {
        var events = await _eventManager.GetUserEvents(message.From.Id);
        var calendar = GenerateCalendarView(events);
        
        await _botClient.SendTextMessageAsync(
            message.Chat.Id,
            calendar,
            parseMode: ParseMode.Markdown
        );
    }
}

public class AnalyticsBot
{
    private readonly IStatisticsService _statisticsService;
    private readonly IChartGenerator _chartGenerator;
    
    public async Task GenerateReport(Message message)
    {
        var stats = await _statisticsService.GetGroupStats(message.Chat.Id);
        var chartImage = await _chartGenerator.CreateChart(stats);
        
        var report = $"Статистика за период:\n" +
                    $"Всего сообщений: {stats.MessageCount}\n" +
                    $"Активных пользователей: {stats.ActiveUsers}\n" +
                    $"Популярные темы: {string.Join(", ", stats.TopTopics)}";
        
        await _botClient.SendPhotoAsync(
            message.Chat.Id,
            new InputFileStream(chartImage, "statistics.png"),
            caption: report
        );
    }
    
    public async Task TrackActivity(Message message)
    {
        await _statisticsService.LogActivity(new ActivityLog
        {
            ChatId = message.Chat.Id,
            UserId = message.From.Id,
            MessageType = message.Type,
            Timestamp = DateTime.UtcNow
        });
    }
    
    public async Task GenerateUserReport(Message message)
    {
        var userData = await _statisticsService.GetUserStats(message.From.Id);
        var userChart = await _chartGenerator.CreateUserActivityChart(userData);
        
        var userReport = $"Ваша активность:\n" +
                        $"Отправлено сообщений: {userData.SentMessages}\n" +
                        $"Среднее количество сообщений в день: {userData.AveragePerDay}\n" +
                        $"Самое активное время: {userData.PeakHour:HH:mm}";
        
        await _botClient.SendPhotoAsync(
            message.Chat.Id,
            new InputFileStream(userChart, "user_stats.png"),
            caption: userReport
        );
    }
}

public class Bot
{
    private readonly ITelegramBotClient _botClient;
    private readonly ILogger _logger;
    private readonly IUpdateHandler _updateHandler;
    
    public Bot(ITelegramBotClient botClient, ILogger logger, IUpdateHandler updateHandler)
    {
        _botClient = botClient;
        _logger = logger;
        _updateHandler = updateHandler;
    }
}

public async Task ProcessUpdatesAsync(IEnumerable<Update> updates)
{
    var tasks = updates.Select(async update =>
    {
        try
        {
            await _updateHandler.HandleUpdateAsync(update);
        }
        catch (Exception ex)
        {
            await _logger.LogErrorAsync(ex);
        }
    });
    
    await Task.WhenAll(tasks);
}

public class CacheService
{
    private readonly IMemoryCache _cache;
    
    public async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> factory)
    {
        if (!_cache.TryGetValue(key, out T value))
        {
            value = await factory();
            _cache.Set(key, value, TimeSpan.FromMinutes(30));
        }
        return value;
    }
}

public class ErrorHandler
{
    private readonly ILogger _logger;
    
    public async Task HandleErrorAsync(Exception exception, CancellationToken ct)
    {
        var errorMessage = exception switch
        {
            ApiRequestException apiRequestException => 
                $"Telegram API Error: {apiRequestException.ErrorCode}",
            TaskCanceledException => "Request timed out",
            _ => "An error occurred"
        };
        
        await _logger.LogErrorAsync(errorMessage, exception);
    }
}

public class BotMetrics
{
    private readonly IMetricsCollector _metrics;
    
    public async Task TrackUpdate(Update update)
    {
        _metrics.IncrementCounter("bot.updates.total");
        _metrics.RecordTiming("bot.processing.time", async () =>
        {
            await ProcessUpdate(update);
        });
    }
}

public class LoggingService
{
    public async Task LogMessage(LogLevel level, string message, Dictionary<string, object> properties)
    {
        var logEntry = new LogEntry
        {
            Level = level,
            Message = message,
            Properties = properties,
            Timestamp = DateTime.UtcNow
        };
        
        await WriteLogAsync(logEntry);
    }
}