У меня есть обработчик событий в моем проекте консольного приложения С#, который запускается при поступлении обновления от пользователя (сценарий чат-бота). Проблема в том, что даже если я использую await внутри обработчика событий, я все равно получаю исключение (недопустимое исключение операции), когда код достигает точки, в которой он хочет получить пользовательские данные из базы данных.
С другой стороны, когда я отпускаю обработчик событий и использую метод длительного опроса для получения обновлений, я не сталкиваюсь с этой проблемой. Я думаю, может быть, этот обработчик событий создает новый поток для каждого получаемого им обновления, поэтому возникает это исключение. Мне было интересно, могу ли я использовать обработчики событий и не сталкиваться с этой проблемой? Вот мой код:
public class TelegramService : IChatbotService
{
private readonly ILogger _logger;
private readonly ITelegramBotClientFactory _telegramBotFactory;
private ITelegramBotClient _telegramBotClient;
internal static User Me;
private readonly IChatbotUpdateHandler _chatbotUpdateHandler;
private readonly ISettingService _settingService;
public TelegramService(ITelegramBotClientFactory telegramBotClientFactory, ILogger<TelegramService> logger,
IChatbotUpdateHandler chatbotUpdateHandler)
{
_logger = logger;
_telegramBotFactory = telegramBotClientFactory;
_chatbotUpdateHandler = chatbotUpdateHandler;
}
public async Task<bool> Run()
{
try
{
_telegramBotClient = _telegramBotFactory.CreateBotClient();
await _telegramBotClient.DeleteWebhookAsync();
Me = await _telegramBotClient.GetMeAsync();
}
catch (Exception e)
{
_logger.LogError($"502 bad gateway, restarting in 2 seconds:\n\n{e.Message}", e.Message);
Thread.Sleep(TimeSpan.FromSeconds(2));
//API is down...
return true;
}
_telegramBotClient.OnUpdate += BotOnUpdateReceived; // event handler
_telegramBotClient.StartReceiving();
return false;
}
private async void BotOnUpdateReceived(object sender, UpdateEventArgs args)
{
var update = args.Update;
if (update.Type == UpdateType.InlineQuery) return;
if (update.Type == UpdateType.CallbackQuery) return;
await _chatbotUpdateHandler.Handle(update);
}
}
public class TelegramUpdateHandler : IChatbotUpdateHandler
{
private Update _update;
private readonly ILogger<TelegramUpdateHandler> _logger;
private readonly IUserService _userService;
private readonly IChatProcessorFactory _chatProcessorFactory;
private readonly IUserMessagingService _userMessagingService;
public TelegramUpdateHandler(ILogger<TelegramUpdateHandler> logger, IUserService userService,
IChatProcessorFactory chatProcessorFactory, IUserMessagingService userMessagingService)
{
_logger = logger;
_userService = userService;
_chatProcessorFactory = chatProcessorFactory;
_userMessagingService = userMessagingService;
}
public async Task Handle(object updateObject)
{
try
{
var botUser = await GetUser();
await ProcessUpdate(botUser);
}
catch (UnAuthorizedException e)
{
//User is grounded or does not have access to bot
_logger.LogInformation($"User is unauthorized to access the bot:\n{e.Message}");
}
catch (Exception e)
{
_logger.LogError($"Error occured at Handle:\n{e.Message}");
}
}
private async Task<BotUser> GetUser()
{
BotUser botUser = null;
try
{
botUser = await _userService.FetchUser(_update.Message.From.Id);
//Exception is thrown when calling "FetchUser" when second update comes here.
}
catch (InvalidOperationException e)
{
botUser = _userService.CreateNewBotUser(_update.Message.From);
botUser = await _userService.AddUserToDb(botUser);
}
return botUser;
}
}
[Export(typeof(IUserService))]
public class UserService : IUserService
{
private readonly ILanguageService _languageService;
private readonly IUnitOfWork _unitOfWork;
private readonly ITelegramApiService _telegramApiService;
[ImportingConstructor]
public UserService(ITelegramApiService telegramApiService, ILanguageService languageService, IUnitOfWork unitOfWork)
{
_telegramApiService = telegramApiService;
_languageService = languageService;
_unitOfWork = unitOfWork;
}
public async Task<BotUser> FetchUser(int userId)
{
return await _unitOfWork.Users.Fetch(userId);
}
}
Если я изменю приведенное выше на что-то вроде приведенного ниже, у меня не возникнет никаких проблем:
var updates = await GetUpdates();
//Through long polling we get the updates rather than using an event handler.
if (updates.Length > 0)
{
HandleUpdates(updates.ToList());
lastUpdateID = updates[^1].Id;
}
///........
private async Task HandleUpdates(List<Update> updates)
{
foreach (var item in updates)
{
if (item.Type == UpdateType.InlineQuery) continue;
if (item.Type == UpdateType.CallbackQuery) continue;
await _chatbotUpdateHandler.Handle(item);
}
}
/// The rest is similar to the previous version
PS*: я также зарегистрировал все свои сервисы как Transient
