Как работать с асинхронными методами и IDisposable в C#?

У меня похожие проблемы, особенно XUnit - проблемный ребенок. Я «решил» это, переместив весь код очистки в тест, например. попытка .. наконец блок. Это менее элегантно, но работает более стабильно и позволяет избежать асинхронного удаления. Если у вас много тестов, вы можете добавить метод, который уменьшает шаблон.

Например:

        private async Task WithFinalizer(Action<Task> toExecute)
    {

        try
        {
            await toExecute();
        }
        finally
        {
           // cleanup here
        }
    }

    // Usage
    [Fact]
    public async Task TestIt()
    {
        await WithFinalizer(async =>
        {
         // your test
         });
    }

Еще одним преимуществом этого является то, что, по моему опыту, очистка часто сильно зависит от теста - с помощью этого метода намного проще предоставить собственный финализатор для каждого теста (добавьте второе действие, которое можно использовать в качестве финализатора).

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

Обычно тесты должны быть разработаны таким образом, чтобы они не зависели от других тестов: тест А должен пройти без запуска теста Б, и наоборот: тесты могут ничего не предполагать о других тестах.

Обычно тест создает некоторое предусловие, вызывает тестируемую функцию и проверяет, выполняется ли постусловие. Поэтому каждый тест обычно создает свою собственную среду.

Если для набора тестов требуется одинаковая среда, то для экономии времени тестирования довольно часто среду создают один раз для всех этих тестов, запускают тесты и удаляют среду. Это то, что вы делаете в своем тестовом классе.

Однако, если в одном из ваших тестов вы создаете задачу для вызова асинхронной функции, вам следует дождаться результата этой задачи внутри этого теста. Если вы этого не сделаете, вы не сможете проверить, делает ли асинхронная функция то, для чего она предназначена, а именно: «Создайте задачу, которая при ожидании возвращает…».

void TestA()
{
    Task taskA = null;
    try
    {
        // start a task without awaiting
        taskA = DoSomethingAsync();
        // perform your test
        ...
        // wait until taskA completes
        taskA.Wait();
        // check the result of taskA
        ...
     }
     catch (Exception exc)
     {
         ...
     }
     finally
     {
         // make sure that even if exception TaskA completes
         taskA.Wait();
     }
 }

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

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

Это означает, что ваш Dispose должен убедиться, что все запущенные задачи, которые не были завершены на момент завершения метода тестирования, ожидаются.

List<Task> nonAwaitedTasks = new List<Task>();

var TestA()
{
    // start a Task, for some reason you don't want to await for it:
    Task taskA = DoSomethingAsync(...);
    // perform your test

    // finish without awaiting for taskA. Make sure it will be awaited before the
    // class is disposed:
    nonAwaitedTasks.Add(taskA);
}

public void Dispose()
{
    Dispose(true);
}
protected void Dispose(bool disposing)
{
    if (disposing)
    {
        // wait for all tasks to complete
        Task.WaitAll(this.nonAwaitedTasks);
    }
}
}

Оказывается, xunit на самом деле включает некоторую поддержку для решения проблемы, с которой я столкнулся. Классы тестов могут реализовывать IAsyncLifetime для инициализации и удаления тестов асинхронным способом. Интерфейс выглядит так:

public interface IAsyncLifetime
{
    Task InitializeAsync();
    Task DisposeAsync();
}

Хотя это решение моей конкретной проблемы, оно не решает более общей проблемы вызова асинхронного метода из Dispose (ни один из текущих ответов не делает этого). Я полагаю, для этого нам нужно будет подождать, пока IAsyncDisposable не станет доступен в .NET core 3.0 (спасибо @MartinUllrich за эту информацию).