Ограничение времени для метода в C #

У меня есть игровая среда, в которой есть список ботов, которые реализуют IBotInterface. Эти боты изготавливаются на заказ пользователем с единственным ограничением, что они должны реализовать интерфейс.

Затем игра вызывает методы в ботах (надеюсь, параллельно) для различных событий, таких как yourTurn и roundStart. Я хочу, чтобы бот потратил ограниченное количество времени на обработку этих событий, прежде чем его заставили прекратить работу на компьютере.

Примером того, что я пытаюсь, является: (где NewGame является делегатом)

Parallel.ForEach(Bots, delegate(IBot bot)
                {
                    NewGame del = bot.NewGame;
                    IAsyncResult r = del.BeginInvoke(Info, null, null);
                    WaitHandle h = r.AsyncWaitHandle;
                    h.WaitOne(RoundLimit);
                    if (!r.IsCompleted)
                    {
                        del.EndInvoke(r);
                    }
                }
            );

В этом случае я вынужден запустить EndInvoke (), который может не завершиться. Я не могу придумать способ чистого прерывания потока.

Было бы здорово, если бы был какой-то

try { 
 bot.NewGame(Info);
} catch (TimeOutException) {
 // Tell bot off.
} finally {
 // Compute things.
}

, но я не думаю, что возможно сделать такую ​​конструкцию.

Цель этого состоит в том, чтобы изящно работать с ИИ, которые имеют случайные бесконечные циклы или занимают много времени для вычисления.

Другой возможный способ решения этой проблемы - иметь что-то вроде этого (с большим количеством C # и меньшим количеством псевдокода)

Class ActionThread {
    pulbic Thread thread { get; set; }
    public Queue<Action> queue { get; set; }

    public void Run() {
        while (true) {
            queue.WaitOne();
            Act a = queue.dequeue();
            a();
        }
    }

Class foo {
    main() {
        ....
        foreach(Bot b in Bots) {
            ActionThread a = getActionThread(b.UniqueID);
            NewGame del = b.NewGame;
            a.queue.queue(del);
        }
        Thread.Sleep(1000);
        foreach (ActionThread a in Threads) {
            a.Suspend();
        }
    }
}

Не самый чистый способ, но это будет Работа. (Я буду беспокоиться о том, как передать параметры и получить возвращаемые значения позже).

Было бы замечательно, если бы был какой-то

try { 
 bot.NewGame(Info);
} catch (TimeOutException) {
 // Tell bot off.
} finally {
 // Compute things.
}

, но я не думаю, что возможно сделать такую ​​конструкцию.

Цель этого состоит в том, чтобы изящно обрабатывать ИИ, которые имеют случайные бесконечные циклы или занимают много времени. время для вычислений.

Другой возможный способ решения этой проблемы - иметь что-то вроде этого (с большим количеством C # и меньшим количеством псевдокодов).

Class ActionThread {
    pulbic Thread thread { get; set; }
    public Queue<Action> queue { get; set; }

    public void Run() {
        while (true) {
            queue.WaitOne();
            Act a = queue.dequeue();
            a();
        }
    }

Class foo {
    main() {
        ....
        foreach(Bot b in Bots) {
            ActionThread a = getActionThread(b.UniqueID);
            NewGame del = b.NewGame;
            a.queue.queue(del);
        }
        Thread.Sleep(1000);
        foreach (ActionThread a in Threads) {
            a.Suspend();
        }
    }
}

Не самый чистый способ, но он будет работать. (Я буду беспокоиться о том, как передать параметры и получить возвращаемые значения позже).

Было бы замечательно, если бы был какой-то

try { 
 bot.NewGame(Info);
} catch (TimeOutException) {
 // Tell bot off.
} finally {
 // Compute things.
}

, но я не думаю, что возможно сделать такую ​​конструкцию.

Цель этого состоит в том, чтобы изящно обрабатывать ИИ, которые имеют случайные бесконечные циклы или занимают много времени. время для вычислений.

Другой возможный способ решения этой проблемы - иметь что-то вроде этого (с большим количеством C # и меньшим количеством псевдокодов).

Class ActionThread {
    pulbic Thread thread { get; set; }
    public Queue<Action> queue { get; set; }

    public void Run() {
        while (true) {
            queue.WaitOne();
            Act a = queue.dequeue();
            a();
        }
    }

Class foo {
    main() {
        ....
        foreach(Bot b in Bots) {
            ActionThread a = getActionThread(b.UniqueID);
            NewGame del = b.NewGame;
            a.queue.queue(del);
        }
        Thread.Sleep(1000);
        foreach (ActionThread a in Threads) {
            a.Suspend();
        }
    }
}

Не самый чистый способ, но он будет работать. (Я буду беспокоиться о том, как передать параметры и получить возвращаемые значения позже).

[Further Edit]

I'm not too sure what an appdomain is, from the looks of it I could do so, but it cant see how it would help

I hope not to expect malicious code. Trying to kill the other bots threads is not a valid way to win the game. I just wanted to give every bot a second to compute then move on with the gameflow so mainly expecting slow or bugged code here.

I'm trying to see what I can do with Task, getting somewhere slowly.

I'll read into what CAS can do, thank you guys

[Подробнее Редактировать]

У меня болит голова, я не могу больше думать или кодировать. Я настраиваю систему передачи сообщений на выделенный поток для каждого бота и приостанавливаю / сплю эти потоки.

Я решил, что буду использовать полностью серверную клиентскую систему с сокетами. Так что клиент может делать все, что он хочет, и я просто проигнорирую, если он отказывается отвечать на сообщения сервера. Жаль, что до этого дошло.