Как мне синхронно запустить асинхронный метод Task ‹T›?

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

Асинхронные методы в C # 5 основаны на эффективном разделении метода на части под капотом и возвращении Task, который может отслеживать общее завершение всего шабанга. Однако то, как выполняются разделенные методы, может зависеть от типа выражения, переданного оператору await.

В большинстве случаев вы будете использовать await в выражении типа Task. Реализация в задаче шаблона await "умна" в том смысле, что она подчиняется SynchronizationContext, что в основном приводит к следующему:

1. Если поток, входящий в await, находится в потоке цикла сообщений Dispatcher или WinForms, это гарантирует, что фрагменты асинхронного метода выполняются как часть обработки очереди сообщений.
2. Если поток, входящий в await, находится в потоке пула потоков, тогда оставшиеся фрагменты асинхронного метода происходят где угодно в пуле потоков.

Вот почему вы, вероятно, столкнетесь с проблемами - реализация асинхронного метода пытается запустить остальное на Диспетчере, даже если он приостановлен.

.... резервное копирование! ....

Я должен задать вопрос: почему вы пытаетесь синхронно блокировать асинхронный метод? Это нарушит цель, почему метод хотел вызываться асинхронно. В общем, когда вы начинаете использовать await в диспетчере или методе пользовательского интерфейса, вы захотите включить весь поток пользовательского интерфейса в асинхронный режим. Например, если ваш стек вызовов был примерно таким:

1. [Вверх] WebRequest.GetResponse()
2. YourCode.HelperMethod()
3. YourCode.AnotherMethod()
4. YourCode.EventHandlerMethod()
5. [UI Code].Plumbing() - WPF или WinForms Код
6. [Цикл сообщений] - WPF или WinForms Цикл сообщений

Затем, как только код будет преобразован для использования async, вы, как правило, получите

1. [Вверх] WebRequest.GetResponseAsync()
2. YourCode.HelperMethodAsync()
3. YourCode.AnotherMethodAsync()
4. YourCode.EventHandlerMethodAsync()
5. [UI Code].Plumbing() - WPF или WinForms Код
6. [Цикл сообщений] - WPF или WinForms Цикл сообщений

Фактически отвечаю

Вышеупомянутый класс AsyncHelpers фактически работает, потому что он ведет себя как вложенный цикл сообщений, но он устанавливает свой собственный параллельный механизм для Dispatcher, а не пытается выполнить на самом Dispatcher. Это один из способов решения вашей проблемы.

Другой обходной путь - выполнить асинхронный метод в потоке пула потоков, а затем дождаться его завершения. Сделать это просто - вы можете сделать это с помощью следующего фрагмента:

var customerList = TaskEx.RunEx(GetCustomers).Result;

Последним API будет Task.Run (...), но с CTP вам понадобятся суффиксы Ex (объяснение здесь).

Это хорошо работает для меня

public static class TaskHelper
{
    public static void RunTaskSynchronously(this Task t)
    {
        var task = Task.Run(async () => await t);
        task.Wait();
    }

    public static T RunTaskSynchronously<T>(this Task<T> t)
    {
        T res = default(T);
        var task = Task.Run(async () => res = await t);
        task.Wait();
        return res;
    }
}

Я сталкивался с этим несколько раз, в основном при модульном тестировании или при разработке службы Windows. В настоящее время я всегда использую эту функцию:

        var runSync = Task.Factory.StartNew(new Func<Task>(async () =>
        {
            Trace.WriteLine("Task runSync Start");
            await TaskEx.Delay(2000); // Simulates a method that returns a task and
                                      // inside it is possible that there
                                      // async keywords or anothers tasks
            Trace.WriteLine("Task runSync Completed");
        })).Unwrap();
        Trace.WriteLine("Before runSync Wait");
        runSync.Wait();
        Trace.WriteLine("After runSync Waited");

Это просто, легко и без проблем.

Самый простой способ, который я нашел для выполнения задачи синхронно и без блокировки потока пользовательского интерфейса, - это использовать RunSynchronously (), например:

Task t = new Task(() => 
{ 
   //.... YOUR CODE ....
});
t.RunSynchronously();

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

Я нашел этот код в компоненте Microsoft.AspNet.Identity.Core, и он работает.

private static readonly TaskFactory _myTaskFactory = new 
     TaskFactory(CancellationToken.None, TaskCreationOptions.None, 
     TaskContinuationOptions.None, TaskScheduler.Default);

// Microsoft.AspNet.Identity.AsyncHelper
public static TResult RunSync<TResult>(Func<Task<TResult>> func)
{
    CultureInfo cultureUi = CultureInfo.CurrentUICulture;
    CultureInfo culture = CultureInfo.CurrentCulture;
    return AsyncHelper._myTaskFactory.StartNew<Task<TResult>>(delegate
    {
        Thread.CurrentThread.CurrentCulture = culture;
        Thread.CurrentThread.CurrentUICulture = cultureUi;
        return func();
    }).Unwrap<TResult>().GetAwaiter().GetResult();
}

Небольшое замечание - этот подход:

Task<Customer> task = GetCustomers();
task.Wait()

работает для WinRT.

Позволь мне объяснить:

private void TestMethod()
{
    Task<Customer> task = GetCustomers(); // call async method as sync and get task as result
    task.Wait(); // wait executing the method
    var customer = task.Result; // get's result.
    Debug.WriteLine(customer.Name); //print customer name
}
public class Customer
{
    public Customer()
    {
        new ManualResetEvent(false).WaitOne(TimeSpan.FromSeconds(5));//wait 5 second (long term operation)
    }
    public string Name { get; set; }
}
private Task<Customer> GetCustomers()
{
    return Task.Run(() => new Customer
    {
        Name = "MyName"
    });
}

Причем этот подход работает только для решений для Магазина Windows!

Примечание. Этот способ небезопасен для потоков, если вы вызываете свой метод внутри другого асинхронного метода (согласно комментариям @Servy).

Протестировано в .Net 4.6. Это также может избежать тупика.

Для асинхронного метода, возвращающего Task.

Task DoSomeWork();
Task.Run(async () => await DoSomeWork()).Wait();

Для асинхронного метода, возвращающего Task<T>

Task<T> GetSomeValue();
var result = Task.Run(() => GetSomeValue()).Result;

Изменить:

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

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

Task<Customer> task = GetCustomers();
task.RunSynchronously();

Изменить:

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

[Test]
public void ExecuteSynchronouslyTest ()
{
        var val = 0;
        Task t = new Task (() => { Thread.Sleep (100); val = 1; });
        t.RunSynchronously ();

        Assert.AreEqual (1, val);
}

Проверьте, работает ли это для вас. Если это не так, хотя это очень маловероятно, у вас может быть странная сборка Async CTP. Если это сработает, вы можете проверить, что именно генерирует компилятор и чем Task создание экземпляра отличается от этого примера.

Изменить № 2:

Я проверил с помощью Reflector, что описанное вами исключение возникает, когда m_action равно null. Это немного странно, но я не эксперт по Async CTP. Как я уже сказал, вам следует декомпилировать свой код и посмотреть, как именно создается экземпляр Task, и почему его m_action равно null.

Почему бы не создать такой звонок:

Service.GetCustomers();

это не асинхронно.

используйте нижеприведенный фрагмент кода

Task.WaitAll(Task.Run(async () => await service.myAsyncMethod()));

ПРИМЕЧАНИЕ. Я считаю, что лучше всего не рекомендуется изменять характер действия, если оно асинхронное, лучше всего обрабатывать его как есть (полностью асинхронно). Таким образом, вы можете получить другие преимущества, такие как параллельная обработка / многопоточность и т. Д.

Видя, что другие ответы не использовали этот подход, я также хочу опубликовать его здесь:

var customers = GetCustomersAsync().GetAwaiter().GetResult();

Этот ответ предназначен для всех, кто использует WPF для .NET 4.5.

Если вы попытаетесь выполнить Task.Run() в потоке графического интерфейса пользователя, task.Wait() будет зависать на неопределенное время, если у вас нет ключевого слова async в определении вашей функции.

Этот метод расширения решает проблему, проверяя, находимся ли мы в потоке графического интерфейса пользователя, и, если да, запускаем задачу в потоке диспетчера WPF.

Этот класс может действовать как связующее звено между миром async / await и миром без async / await в ситуациях, когда это неизбежно, например, свойства MVVM или зависимости от других API, которые не используют async / await.

/// <summary>
///     Intent: runs an async/await task synchronously. Designed for use with WPF.
///     Normally, under WPF, if task.Wait() is executed on the GUI thread without async
///     in the function signature, it will hang with a threading deadlock, this class 
///     solves that problem.
/// </summary>
public static class TaskHelper
{
    public static void MyRunTaskSynchronously(this Task task)
    {
        if (MyIfWpfDispatcherThread)
        {
            var result = Dispatcher.CurrentDispatcher.InvokeAsync(async () => { await task; });
            result.Wait();
            if (result.Status != DispatcherOperationStatus.Completed)
            {
                throw new Exception("Error E99213. Task did not run to completion.");
            }
        }
        else
        {
            task.Wait();
            if (task.Status != TaskStatus.RanToCompletion)
            {
                throw new Exception("Error E33213. Task did not run to completion.");
            }
        }
    }

    public static T MyRunTaskSynchronously<T>(this Task<T> task)
    {       
        if (MyIfWpfDispatcherThread)
        {
            T res = default(T);
            var result = Dispatcher.CurrentDispatcher.InvokeAsync(async () => { res = await task; });
            result.Wait();
            if (result.Status != DispatcherOperationStatus.Completed)
            {
                throw new Exception("Error E89213. Task did not run to completion.");
            }
            return res;
        }
        else
        {
            T res = default(T);
            var result = Task.Run(async () => res = await task);
            result.Wait();
            if (result.Status != TaskStatus.RanToCompletion)
            {
                throw new Exception("Error E12823. Task did not run to completion.");
            }
            return res;
        }
    }

    /// <summary>
    ///     If the task is running on the WPF dispatcher thread.
    /// </summary>
    public static bool MyIfWpfDispatcherThread
    {
        get
        {
            return Application.Current.Dispatcher.CheckAccess();
        }
    }
}

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

private TResult InvokeAsyncFuncSynchronously<TResult>(Func< Task<TResult>> func)
    {
        TResult result = default(TResult);
        var autoResetEvent = new AutoResetEvent(false);

        Task.Run(async () =>
        {
            try
            {
                result = await func();
            }
            catch (Exception exc)
            {
                mErrorLogger.LogError(exc.ToString());
            }
            finally
            {
                autoResetEvent.Set();
            }
        });
        autoResetEvent.WaitOne();

        return result;
    }

Может использоваться следующим образом:

InvokeAsyncFuncSynchronously(Service.GetCustomersAsync);

Простой вызов .Result; или .Wait() - это риск возникновения тупиковых ситуаций, о чем многие говорили в комментариях. Поскольку большинству из нас нравятся одинарные лайнеры, вы можете использовать их для .Net 4.5<

Получение значения с помощью асинхронного метода:

var result = Task.Run(() => asyncGetValue()).Result;

Синхронный вызов асинхронного метода

Task.Run(() => asyncMethod()).Wait();

Никаких проблем с взаимоблокировкой не возникнет из-за использования Task.Run.

Источник:

https://stackoverflow.com/a/32429753/3850405

Это работает для меня

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    public static class AsyncHelper
    {
        private static readonly TaskFactory _myTaskFactory = new TaskFactory(CancellationToken.None, TaskCreationOptions.None, TaskContinuationOptions.None, TaskScheduler.Default);

        public static void RunSync(Func<Task> func)
        {
            _myTaskFactory.StartNew(func).Unwrap().GetAwaiter().GetResult();
        }

        public static TResult RunSync<TResult>(Func<Task<TResult>> func)
        {
            return _myTaskFactory.StartNew(func).Unwrap().GetAwaiter().GetResult();
        }
    }

    class SomeClass
    {
        public async Task<object> LoginAsync(object loginInfo)
        {
            return await Task.FromResult(0);
        }
        public object Login(object loginInfo)
        {
            return AsyncHelper.RunSync(() => LoginAsync(loginInfo));
            //return this.LoginAsync(loginInfo).Result.Content;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var someClass = new SomeClass();

            Console.WriteLine(someClass.Login(1));
            Console.ReadLine();
        }
    }
}

Я обнаружил, что SpinWait отлично подходит для этого.

var task = Task.Run(()=>DoSomethingAsyncronous());

if(!SpinWait.SpinUntil(()=>task.IsComplete, TimeSpan.FromSeconds(30)))
{//Task didn't complete within 30 seconds, fail...
   return false;
}

return true;

Вышеупомянутый подход не требует использования .Result или .Wait (). Это также позволяет вам указать тайм-аут, чтобы вы не застряли навсегда, если задача никогда не завершится.

On wp8:

Заверните это:

Task GetCustomersSynchronously()
{
    Task t = new Task(async () =>
    {
        myCustomers = await GetCustomers();
    }
    t.RunSynchronously();
}

Назови это:

GetCustomersSynchronously();

Или вы можете просто пойти с:

customerList = Task.Run<List<Customer>>(() => { return GetCustomers(); }).Result;

Чтобы это скомпилировать, убедитесь, что вы ссылаетесь на сборку расширения:

System.Net.Http.Formatting

Попробуйте следующий код, который у меня работает:

public async void TaskSearchOnTaskList (SearchModel searchModel)
{
    try
    {
        List<EventsTasksModel> taskSearchList = await Task.Run(
            () => MakeasyncSearchRequest(searchModel),
            cancelTaskSearchToken.Token);

        if (cancelTaskSearchToken.IsCancellationRequested
                || string.IsNullOrEmpty(rid_agendaview_search_eventsbox.Text))
        {
            return;
        }

        if (taskSearchList == null || taskSearchList[0].result == Constants.ZERO)
        {
            RunOnUiThread(() => {
                textViewNoMembers.Visibility = ViewStates.Visible;                  
                taskListView.Visibility = ViewStates.Gone;
            });

            taskSearchRecureList = null;

            return;
        }
        else
        {
            taskSearchRecureList = TaskFooterServiceLayer
                                       .GetRecurringEvent(taskSearchList);

            this.SetOnAdapter(taskSearchRecureList);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("ActivityTaskFooter -> TaskSearchOnTaskList:" + ex.Message);
    }
}