Async/Await и Task — бесплатный тест онлайн

Вопрос 1 из 25

Раздел «Асинхронная функция»: что здесь является частью контракта, а не особенностью одного удачного запуска?

Imports System.Threading.Tasks
Module Demo
    Async Function LoadAsync() As Task(Of Integer)
        Await Task.Delay(10)
        Return 3
    End Function
End Module

Контракт Асинхронная функция можно сократить до «Async Function обычно возвращает Task или Task(Of T)»; часть «а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом» остаётся лишь рекомендацией. Async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом. Async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её можно ожидать и нормально перехватить исключение вызывающим кодом. Async Sub возвращает скрытый Task, который вызывающий код может ожидать и перехватить через обычный Try/Catch. Async Function обычно не возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом.

Вопрос 2 из 25

Раздел «Асинхронная функция»: какое ограничение нельзя убрать только потому, что обычный пример проходит?

Option Strict On
Imports System.Threading.Tasks
Namespace ReviewCase14_1
    Module Demo
        Async Function LoadAsync() As Task(Of Integer)
            Await Task.Delay(11)
            Return 7
        End Function
    End Module
End Namespace

Зафиксировать в ревью: async Sub возвращает скрытый Task, который вызывающий код может ожидать и перехватить через обычный Try/Catch. Зафиксировать в ревью: async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом. Зафиксировать в ревью: контракт Асинхронная функция можно сократить до «Async Function обычно возвращает Task или Task(Of T)»; часть «а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом» остаётся лишь рекомендацией. Зафиксировать в ревью: async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её можно ожидать и нормально перехватить исключение вызывающим кодом. Зафиксировать в ревью: async Function обычно не возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом.

Вопрос 3 из 25

Какое свойство механизма «Асинхронная функция» нужно проверить на редком, но допустимом сценарии?

Option Explicit On
Option Infer On
Imports System.Threading.Tasks
Namespace BoundaryCase14_1
    Module Demo
        Async Function LoadAsync() As Task(Of Integer)
            Await Task.Delay(9)
            Return 1
        End Function
    End Module
End Namespace

Закрепить тестом: async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом. Закрепить тестом: контракт Асинхронная функция можно сократить до «Async Function обычно возвращает Task или Task(Of T)»; часть «а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом» остаётся лишь рекомендацией. Закрепить тестом: async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её можно ожидать и нормально перехватить исключение вызывающим кодом. Закрепить тестом: async Sub возвращает скрытый Task, который вызывающий код может ожидать и перехватить через обычный Try/Catch. Закрепить тестом: async Function обычно не возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом.

Вопрос 4 из 25

Какое решение соответствует реальному времени жизни объектов и правилам «Асинхронная функция»?

Закрепить рабочее решение: async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её можно ожидать и нормально перехватить исключение вызывающим кодом. Закрепить рабочее решение: async Sub возвращает скрытый Task, который вызывающий код может ожидать и перехватить через обычный Try/Catch. Закрепить рабочее решение: async Function обычно не возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом. Закрепить рабочее решение: контракт Асинхронная функция можно сократить до «Async Function обычно возвращает Task или Task(Of T)»; часть «а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом» остаётся лишь рекомендацией. Закрепить рабочее решение: async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом.

Вопрос 5 из 25

Что можно считать надёжным рабочим правилом для раздела «Асинхронная функция»?

Технически точный принцип: async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом. Технически точный принцип: контракт Асинхронная функция можно сократить до «Async Function обычно возвращает Task или Task(Of T)»; часть «а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом» остаётся лишь рекомендацией. Технически точный принцип: async Sub возвращает скрытый Task, который вызывающий код может ожидать и перехватить через обычный Try/Catch. Технически точный принцип: async Function обычно не возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её нельзя ожидать и нормально перехватить исключение вызывающим кодом. Технически точный принцип: async Function обычно возвращает Task или Task(Of T), а Async Sub допустима главным образом для обработчиков событий, потому что её можно ожидать и нормально перехватить исключение вызывающим кодом.

Вопрос 6 из 25

Раздел «Ожидание через Await»: что в этом коде определяет результат, а не случайное совпадение тестовых данных?

Imports System.Threading.Tasks
Module Demo
    Async Function RunAsync() As Task
        Console.Write("A")
        Await Task.Delay(10)
        Console.Write("B")
    End Function
End Module

Await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и не продолжает его в согласованном контексте. Await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Await не создаёт отдельный поток и не блокирует текущий; он не приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Await создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод после завершения Task и продолжает его в согласованном контексте.

Вопрос 7 из 25

Раздел «Ожидание через Await»: какой комментарий к изменению будет технически обоснован?

Option Strict On
Imports System.Threading.Tasks
Namespace ReviewCase14_2
    Module Demo
        Async Function RunAsync() As Task
            Console.Write("A")
            Await Task.Delay(11)
            Console.Write("B")
        End Function
    End Module
End Namespace

Зафиксировать в ревью: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод после завершения Task и продолжает его в согласованном контексте. Зафиксировать в ревью: await создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Зафиксировать в ревью: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и не продолжает его в согласованном контексте. Зафиксировать в ревью: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Зафиксировать в ревью: await не создаёт отдельный поток и не блокирует текущий; он не приостанавливает метод до завершения Task и продолжает его в согласованном контексте.

Вопрос 8 из 25

Раздел «Ожидание через Await»: какое утверждение поможет отличить настоящий дефект от случайности тестовых данных?

Option Explicit On
Option Infer On
Imports System.Threading.Tasks
Namespace BoundaryCase14_2
    Module Demo
        Async Function RunAsync() As Task
            Console.Write("A")
            Await Task.Delay(9)
            Console.Write("B")
        End Function
    End Module
End Namespace

Добавить регрессионную проверку: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод после завершения Task и продолжает его в согласованном контексте. Добавить регрессионную проверку: await создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Добавить регрессионную проверку: await не создаёт отдельный поток и не блокирует текущий; он не приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Добавить регрессионную проверку: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Добавить регрессионную проверку: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и не продолжает его в согласованном контексте.

Вопрос 9 из 25

Раздел «Ожидание через Await»: что стоит закрепить в коде и тестах, а не прикрывать общим обработчиком?

Не скрывать за запасным сценарием: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и не продолжает его в согласованном контексте. Не скрывать за запасным сценарием: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Не скрывать за запасным сценарием: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод после завершения Task и продолжает его в согласованном контексте. Не скрывать за запасным сценарием: await создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Не скрывать за запасным сценарием: await не создаёт отдельный поток и не блокирует текущий; он не приостанавливает метод до завершения Task и продолжает его в согласованном контексте.

Вопрос 10 из 25

Какое правило по теме «Ожидание через Await» можно безопасно перенести из примера в реальный проект?

Переносимый вывод: await создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Переносимый вывод: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Переносимый вывод: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод до завершения Task и не продолжает его в согласованном контексте. Переносимый вывод: await не создаёт отдельный поток и не блокирует текущий; он не приостанавливает метод до завершения Task и продолжает его в согласованном контексте. Переносимый вывод: await не создаёт отдельный поток и не блокирует текущий; он приостанавливает метод после завершения Task и продолжает его в согласованном контексте.

Вопрос 11 из 25

Не запуская фрагмент, выберите объяснение, которое учитывает весь механизм «Параллельные задачи».

Imports System.Threading.Tasks
Module Demo
    Async Function LoadBothAsync() As Task(Of Integer())
        Dim first = LoadAsync(1)
        Dim second = LoadAsync(2)
        Return Await Task.WhenAll(first, second)
    End Function
    Function LoadAsync(id As Integer) As Task(Of Integer)
        Return Task.FromResult(id)
    End Function
End Module

Наблюдаемое поведение: независимые операции запускают до ожидания и не объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Наблюдаемое поведение: независимые операции запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Наблюдаемое поведение: независимые операции запускают до ожидания и объединяют Task.WhenAll; параллельные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Наблюдаемое поведение: независимые операции не запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Наблюдаемое поведение: независимые операции запускают после ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки.

Вопрос 12 из 25

Раздел «Параллельные задачи»: какой комментарий к изменению будет технически обоснован?

Option Strict On
Imports System.Threading.Tasks
Namespace ReviewCase14_3
    Module Demo
        Async Function LoadBothAsync() As Task(Of Integer())
            Dim reviewFirst = LoadAsync(1)
            Dim reviewSecond = LoadAsync(3)
            Return Await Task.WhenAll(reviewFirst, reviewSecond)
        End Function
        Function LoadAsync(reviewId As Integer) As Task(Of Integer)
            Return Task.FromResult(reviewId)
        End Function
    End Module
End Namespace

Сохранить на ревью: независимые операции не запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Сохранить на ревью: независимые операции запускают после ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Сохранить на ревью: независимые операции запускают до ожидания и не объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Сохранить на ревью: независимые операции запускают до ожидания и объединяют Task.WhenAll; параллельные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Сохранить на ревью: независимые операции запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки.

Вопрос 13 из 25

Раздел «Параллельные задачи»: какой результат следует зафиксировать до запуска отрицательного сценария?

Option Explicit On
Option Infer On
Imports System.Threading.Tasks
Namespace BoundaryCase14_3
    Module Demo
        Async Function LoadBothAsync() As Task(Of Integer())
            Dim edgeFirst = LoadAsync(1)
            Dim edgeSecond = LoadAsync(1)
            Return Await Task.WhenAll(edgeFirst, edgeSecond)
        End Function
        Function LoadAsync(edgeId As Integer) As Task(Of Integer)
            Return Task.FromResult(edgeId)
        End Function
    End Module
End Namespace

Зафиксировать ожидаемое поведение: независимые операции запускают до ожидания и объединяют Task.WhenAll; параллельные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Зафиксировать ожидаемое поведение: независимые операции запускают до ожидания и не объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Зафиксировать ожидаемое поведение: независимые операции запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Зафиксировать ожидаемое поведение: независимые операции запускают после ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Зафиксировать ожидаемое поведение: независимые операции не запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки.

Вопрос 14 из 25

Раздел «Параллельные задачи»: какое решение выдержит не только демонстрационный, но и отказный сценарий?

Оставить в коде и тестах условие: независимые операции запускают до ожидания и объединяют Task.WhenAll; параллельные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Оставить в коде и тестах условие: независимые операции запускают до ожидания и не объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Оставить в коде и тестах условие: независимые операции запускают после ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Оставить в коде и тестах условие: независимые операции запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Оставить в коде и тестах условие: независимые операции не запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки.

Вопрос 15 из 25

Что точнее всего описывает механизм «Параллельные задачи»?

Технически точный принцип: независимые операции запускают после ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Технически точный принцип: независимые операции не запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Технически точный принцип: независимые операции запускают до ожидания и объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Технически точный принцип: независимые операции запускают до ожидания и объединяют Task.WhenAll; параллельные Await нужны только при зависимости результата или намеренном ограничении нагрузки. Технически точный принцип: независимые операции запускают до ожидания и не объединяют Task.WhenAll; последовательные Await нужны только при зависимости результата или намеренном ограничении нагрузки.

Вопрос 16 из 25

Раздел «Обработка исключений»: что в этом коде определяет результат, а не случайное совпадение тестовых данных?

Imports System.Threading.Tasks
Module Demo
    Async Function ReadAsync() As Task(Of String)
        Try
            Return Await Task.FromException(Of String)(New IOException("disk"))
        Catch ex As IOException
            Return "fallback"
        End Try
    End Function
End Module

Контракт кода: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task не оставляет ошибку без контекста. Контракт кода: исключение асинхронной операции не наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Контракт кода: исключение асинхронной операции наблюдается при Await; try/catch не должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Контракт кода: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Контракт кода: при работе с Обработка исключений нарушение «Исключение асинхронной операции наблюдается при Await» не меняет результат, если выполняется «try/catch должен охватывать фактическое ожидание».

Вопрос 17 из 25

Раздел «Обработка исключений»: какую договорённость важнее сохранить, чем выиграть несколько строк кода?

Option Strict On
Imports System.Threading.Tasks
Namespace ReviewCase14_4
    Module Demo
        Async Function ReadAsync() As Task(Of String)
            Try
                Return Await Task.FromException(Of String)(New IOException("disk"))
            Catch reviewEx As IOException
                Return "fallback"
            End Try
        End Function
    End Module
End Namespace

Не менять условие: исключение асинхронной операции наблюдается при Await; try/catch не должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Не менять условие: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Не менять условие: исключение асинхронной операции не наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Не менять условие: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task не оставляет ошибку без контекста. Не менять условие: при работе с Обработка исключений нарушение «Исключение асинхронной операции наблюдается при Await» не меняет результат, если выполняется «try/catch должен охватывать фактическое ожидание».

Вопрос 18 из 25

Раздел «Обработка исключений»: какое утверждение поможет отличить настоящий дефект от случайности тестовых данных?

Option Explicit On
Option Infer On
Imports System.Threading.Tasks
Namespace BoundaryCase14_4
    Module Demo
        Async Function ReadAsync() As Task(Of String)
            Try
                Return Await Task.FromException(Of String)(New IOException("disk"))
            Catch edgeEx As IOException
                Return "fallback"
            End Try
        End Function
    End Module
End Namespace

Добавить регрессионную проверку: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task не оставляет ошибку без контекста. Добавить регрессионную проверку: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Добавить регрессионную проверку: исключение асинхронной операции наблюдается при Await; try/catch не должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Добавить регрессионную проверку: исключение асинхронной операции не наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Добавить регрессионную проверку: при работе с Обработка исключений нарушение «Исключение асинхронной операции наблюдается при Await» не меняет результат, если выполняется «try/catch должен охватывать фактическое ожидание».

Вопрос 19 из 25

Раздел «Обработка исключений»: какой вариант оставляет важное условие явным для следующего разработчика?

Закрепить рабочее решение: при работе с Обработка исключений нарушение «Исключение асинхронной операции наблюдается при Await» не меняет результат, если выполняется «try/catch должен охватывать фактическое ожидание». Закрепить рабочее решение: исключение асинхронной операции не наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Закрепить рабочее решение: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task не оставляет ошибку без контекста. Закрепить рабочее решение: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Закрепить рабочее решение: исключение асинхронной операции наблюдается при Await; try/catch не должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста.

Вопрос 20 из 25

Раздел «Обработка исключений»: какой вывод можно использовать как основание для ревью кода?

Технически точный принцип: исключение асинхронной операции не наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Технически точный принцип: исключение асинхронной операции наблюдается при Await; try/catch не должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Технически точный принцип: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task не оставляет ошибку без контекста. Технически точный принцип: исключение асинхронной операции наблюдается при Await; try/catch должен охватывать фактическое ожидание, а потерянный Task оставляет ошибку без контекста. Технически точный принцип: при работе с Обработка исключений нарушение «Исключение асинхронной операции наблюдается при Await» не меняет результат, если выполняется «try/catch должен охватывать фактическое ожидание».

Вопрос 21 из 25

Раздел «Ошибки интеграции»: какое утверждение позволяет предсказать поведение фрагмента по правилам Visual Basic и .NET?

Imports System.Threading
Imports System.Threading.Tasks
Class SearchController
    Private current As CancellationTokenSource
    Public Async Function SearchAsync(text As String) As Task(Of String)
        current?.Cancel()
        current = New CancellationTokenSource()
        Await Task.Delay(30, current.Token)
        Return text.ToUpperInvariant()
    End Function
End Class

В обработчике интерфейса .Result безопасен для короткой операции: взаимная блокировка возможна только у длительных задач. Достаточно явно обеспечить «Интеграция async с интерфейсом требует отмены»; требование «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку» на поведение не влияет. Интеграция async с интерфейсом не требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку. Интеграция async с интерфейсом требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку. При работе с Ошибки интеграции нарушение «Интеграция async с интерфейсом требует отмены» не меняет результат, если выполняется «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку».

Вопрос 22 из 25

Раздел «Ошибки интеграции»: какую договорённость важнее сохранить, чем выиграть несколько строк кода?

Option Strict On
Imports System.Threading
Imports System.Threading.Tasks
Namespace ReviewCase14_5
    Class SearchController
        Private current As CancellationTokenSource
        Public Async Function SearchAsync(reviewText As String) As Task(Of String)
            current?.Cancel()
            current = New CancellationTokenSource()
            Await Task.Delay(31, current.Token)
            Return reviewText.ToUpperInvariant()
        End Function
    End Class
End Namespace

Проверить перед объединением: интеграция async с интерфейсом требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку. Проверить перед объединением: при работе с Ошибки интеграции нарушение «Интеграция async с интерфейсом требует отмены» не меняет результат, если выполняется «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку». Проверить перед объединением: достаточно явно обеспечить «Интеграция async с интерфейсом требует отмены»; требование «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку» на поведение не влияет. Проверить перед объединением: в обработчике интерфейса .Result безопасен для короткой операции: взаимная блокировка возможна только у длительных задач. Проверить перед объединением: интеграция async с интерфейсом не требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку.

Вопрос 23 из 25

Раздел «Ошибки интеграции»: что именно должен локализовать полезный граничный тест для этого кода?

Option Explicit On
Option Infer On
Imports System.Threading
Imports System.Threading.Tasks
Namespace BoundaryCase14_5
    Class SearchController
        Private current As CancellationTokenSource
        Public Async Function SearchAsync(edgeText As String) As Task(Of String)
            current?.Cancel()
            current = New CancellationTokenSource()
            Await Task.Delay(29, current.Token)
            Return edgeText.ToUpperInvariant()
        End Function
    End Class
End Namespace

Добавить регрессионную проверку: достаточно явно обеспечить «Интеграция async с интерфейсом требует отмены»; требование «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку» на поведение не влияет. Добавить регрессионную проверку: при работе с Ошибки интеграции нарушение «Интеграция async с интерфейсом требует отмены» не меняет результат, если выполняется «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку». Добавить регрессионную проверку: в обработчике интерфейса .Result безопасен для короткой операции: взаимная блокировка возможна только у длительных задач. Добавить регрессионную проверку: интеграция async с интерфейсом не требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку. Добавить регрессионную проверку: интеграция async с интерфейсом требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку.

Вопрос 24 из 25

Раздел «Ошибки интеграции»: какой вариант оставляет важное условие явным для следующего разработчика?

Сделать явным правилом модуля: интеграция async с интерфейсом требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку. Сделать явным правилом модуля: интеграция async с интерфейсом не требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку. Сделать явным правилом модуля: достаточно явно обеспечить «Интеграция async с интерфейсом требует отмены»; требование «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку» на поведение не влияет. Сделать явным правилом модуля: в обработчике интерфейса .Result безопасен для короткой операции: взаимная блокировка возможна только у длительных задач. Сделать явным правилом модуля: при работе с Ошибки интеграции нарушение «Интеграция async с интерфейсом требует отмены» не меняет результат, если выполняется «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку».

Вопрос 25 из 25

Раздел «Ошибки интеграции»: какое обобщение не зависит от случайных деталей показанного примера?

Технически точный принцип: при работе с Ошибки интеграции нарушение «Интеграция async с интерфейсом требует отмены» не меняет результат, если выполняется «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку». Технически точный принцип: интеграция async с интерфейсом требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку. Технически точный принцип: достаточно явно обеспечить «Интеграция async с интерфейсом требует отмены»; требование «защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку» на поведение не влияет. Технически точный принцип: в обработчике интерфейса .Result безопасен для короткой операции: взаимная блокировка возможна только у длительных задач. Технически точный принцип: интеграция async с интерфейсом не требует отмены, защиты от позднего результата и отсутствия блокировок .Result или Wait, которые способны вызвать взаимную блокировку.