C # zaman uyumlu yöntemden zaman uyumsuz yöntemi nasıl çağırılır?

Sahibim public async void Foo()Eşzamanlı yöntemden aramak istediğim yöntem var. Şimdiye kadar MSDN belgelerinde gördüğüm tek şey, zaman uyumsuz yöntemlerle zaman uyumsuz yöntemler çağırıyor, ama tüm programım zaman uyumsuz yöntemlerle inşa edilmemiştir.

Bu mümkün mü?

Bu yöntemleri eşzamansız bir yöntemle çağırmanın bir örneği: http://msdn.microsoft.com/en-us/library/hh300224(v=vs.110).aspx

Şimdi bu asenkron yöntemleri senkronizasyon yöntemlerinden çağırıyorum.

Zaman uyumsuz programlama kod tabanı üzerinden "büyür". Bu edilmiş bir zombi virüsü ile karşılaştırıldığında . En iyi çözüm büyümesine izin vermektir, ancak bazen bu mümkün değildir.

Ben Nito.AsyncEx benim birkaç tür yazdımKısmen eşzamansız kod tabanı ile uğraşmak için kütüphanemde . Yine de her durumda çalışan bir çözüm yok.

Çözüm A

Bağlamına geri senkronize edilmesi gerekmeyen basit bir eşzamansız yönteminiz varsa, şunları kullanabilirsiniz Task.WaitAndUnwrapException:

var task = MyAsyncMethod();
var result = task.WaitAndUnwrapException();

Sen do not kullanmak istediğiniz Task.Waitveya Task.Resultonlar istisnalar sarın çünkü AggregateException.

Bu çözüm yalnızca MyAsyncMethodiçeriğiyle senkronize edilmezse uygundur . Bir başka deyişle, her awaityer MyAsyncMethodbitmelidir ConfigureAwait(false). Bu, herhangi bir UI öğesini güncelleyemeyeceği veya ASP.NET istek içeriğine erişemeyeceği anlamına gelir.

Çözüm B

Eğer MyAsyncMethodkendi bağlamına senkronize arkasına ihtiyacı da artar, ardından kullanmak mümkün olabilir AsyncContext.RunTaskyuvalanmış bir bağlam sağlamak için:

var result = AsyncContext.RunTask(MyAsyncMethod).Result;

* Güncelleme 4/14/2014: Kütüphanenin daha yeni sürümlerinde API aşağıdaki gibidir:

var result = AsyncContext.Run(MyAsyncMethod);

( Task.ResultBu örnekte kullanmak uygun , çünkü RunTaskyayılacakTask İstisnalar ).

Bunun AsyncContext.RunTaskyerine ihtiyaç duymanızın nedeni Task.WaitAndUnwrapException, WinForms / WPF / SL / ASP.NET'te gerçekleşen oldukça ince bir kilitlenme olasılığıdır:

1. Eşzamanlı bir yöntem, a Task.
2. Eşzamanlı yöntem, üzerinde engelleme beklemesi yapar Task.
3. asyncYöntemini kullanır awaitolmadan ConfigureAwait.
4. TaskZaman sadece tamamlar, çünkü bu durumda tamamlayamıyor asyncyöntem bitmiş olduğu; asyncyöntem tam değil onun devamını planlamak için çalışıyor çünkü SynchronizationContext, ve WinForms / WPF / SL / ASP.NET senkron yöntem zaten bu bağlamda çalışıyor çünkü devamı çalışmasına izin vermeyecektir.

Bu, ConfigureAwait(false)her asyncyöntemde mümkün olduğunca kullanılmasının iyi bir fikir olmasının bir nedenidir .

Çözüm C

AsyncContext.RunTaskher senaryoda çalışmaz. Örneğin, asyncyöntem tamamlanması için bir UI olayı gerektiren bir şey beklerse, iç içe bağlamda bile kilitleneceksiniz. Bu durumda, asyncyöntemi thread havuzunda başlatabilirsiniz :

var task = Task.Run(async () => await MyAsyncMethod());
var result = task.WaitAndUnwrapException();

Ancak, bu çözüm MyAsyncMethodiş parçacığı havuzu bağlamında çalışacak bir gerektirir . Bu yüzden UI öğelerini güncelleyemez veya ASP.NET istek içeriğine erişemez. Ve bu durumda, siz de ekleyebilirsiniz ConfigureAwait(false)için onunawait tabloların ve çözüm A'yı kullanmak

Güncelleme, 2019-05-01: Geçerli "en kötü uygulamalar" burada bir MSDN makalesinde bulunmaktadır .

Sonunda sorunumu çözen bir çözüm eklemek, umarım birinin zamanından tasarruf etmesini sağlar.

Önce Stephen Cleary'nin birkaç makalesini okuyun :

• Eşzamansız ve Bekliyor
• Zaman Uyumsuz Kodda Engelleme

"Eşzamansız Kodda Engelleme" bölümündeki "en iyi iki uygulama" dan birincisi benim için çalışmadı ve ikincisi uygulanamazdı (temelde kullanabilirsem await, kullanıyorum !).

İşte benim geçici çözüm: çağrıyı bir sarın Task.Run<>(async () => await FunctionAsync());ve umarım artık kilitlenmez .

İşte benim kod:

public class LogReader
{
    ILogger _logger;

    public LogReader(ILogger logger)
    {
        _logger = logger;
    }

    public LogEntity GetLog()
    {
        Task<LogEntity> task = Task.Run<LogEntity>(async () => await GetLogAsync());
        return task.Result;
    }

    public async Task<LogEntity> GetLogAsync()
    {
        var result = await _logger.GetAsync();
        // more code here...
        return result as LogEntity;
    }
}

Microsoft, Async'i Sync olarak çalıştırmak için bir AsyncHelper (dahili) sınıfı oluşturdu. Kaynak şöyle görünür:

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

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

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

Microsoft.AspNet.Identity temel sınıflarının yalnızca Async yöntemleri vardır ve bunları Sync olarak adlandırmak için, uzantı yöntemlerine sahip sınıflar vardır (örnek kullanım):

public static TUser FindById<TUser, TKey>(this UserManager<TUser, TKey> manager, TKey userId) where TUser : class, IUser<TKey> where TKey : IEquatable<TKey>
{
    if (manager == null)
    {
        throw new ArgumentNullException("manager");
    }
    return AsyncHelper.RunSync<TUser>(() => manager.FindByIdAsync(userId));
}

public static bool IsInRole<TUser, TKey>(this UserManager<TUser, TKey> manager, TKey userId, string role) where TUser : class, IUser<TKey> where TKey : IEquatable<TKey>
{
    if (manager == null)
    {
        throw new ArgumentNullException("manager");
    }
    return AsyncHelper.RunSync<bool>(() => manager.IsInRoleAsync(userId, role));
}

Kodun lisans şartları hakkında endişe duyanlar için, Microsoft tarafından MIT Lisanslı olduğunu gösteren yorumlar içeren çok benzer bir koda (iş parçacığındaki kültür için destek ekler) bir bağlantı. https://github.com/aspnet/AspNetIdentity/blob/master/src/Microsoft.AspNet.Identity.Core/AsyncHelper.cs

async Main artık C # 7.2'nin bir parçasıdır ve projelerin gelişmiş derleme ayarlarında etkinleştirilebilir.

C # <7.2 için doğru yol:

static void Main(string[] args)
{
   MainAsync().GetAwaiter().GetResult();
}


static async Task MainAsync()
{
   /*await stuff here*/
}

Bunun birçok Microsoft belgesinde kullanıldığını göreceksiniz, örneğin: https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-dotnet-how-to-use- konular-abonelikleri

public async Task<string> StartMyTask()
{
    await Foo()
    // code to execute once foo is done
}

static void Main()
{
     var myTask = StartMyTask(); // call your method which will return control once it hits await
     // now you can continue executing code here
     string result = myTask.Result; // wait for the task to complete to continue
     // use result

}

'Await' anahtar kelimesini "bu uzun süren görevi başlat, sonra denetimi çağıran yönteme döndür" şeklinde okudunuz. Uzun süren görev tamamlandıktan sonra kodu bundan sonra yürütür. Beklemeden sonraki kod, CallBack yöntemleri olarak kullanılana benzer. Mantıksal akış olması arasındaki en büyük fark, yazmayı ve okumayı çok daha kolay hale getiren kesintiye uğramaz.

% 100 emin değilim, ancak bu blogda açıklanan tekniğin birçok durumda çalışması gerektiğine inanıyorum :

Bu nedenle, task.GetAwaiter().GetResult()bu yayılma mantığını doğrudan çağırmak istiyorsanız kullanabilirsiniz .

Bununla birlikte, her durumda çalışan (neredeyse: yorumlara bakın) iyi bir çözüm vardır: geçici bir mesaj pompası (SynchronizationContext).

Arama iş parçacığı beklendiği gibi engellenir, ancak zaman uyumsuz işlevinden çağrılan tüm sürekliliklerin, arama iş parçacığında çalışan geçici SynchronizationContext (ileti pompası) ile birleştirileceklerinden kilitlenmemelerini sağlar.

Geçici mesaj pompası yardımcısının kodu:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.Threading
{
    /// <summary>Provides a pump that supports running asynchronous methods on the current thread.</summary>
    public static class AsyncPump
    {
        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static void Run(Action asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(true);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function
                syncCtx.OperationStarted();
                asyncMethod();
                syncCtx.OperationCompleted();

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static void Run(Func<Task> asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(false);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function and alert the context to when it completes
                var t = asyncMethod();
                if (t == null) throw new InvalidOperationException("No task provided.");
                t.ContinueWith(delegate { syncCtx.Complete(); }, TaskScheduler.Default);

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
                t.GetAwaiter().GetResult();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static T Run<T>(Func<Task<T>> asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(false);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function and alert the context to when it completes
                var t = asyncMethod();
                if (t == null) throw new InvalidOperationException("No task provided.");
                t.ContinueWith(delegate { syncCtx.Complete(); }, TaskScheduler.Default);

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
                return t.GetAwaiter().GetResult();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Provides a SynchronizationContext that's single-threaded.</summary>
        private sealed class SingleThreadSynchronizationContext : SynchronizationContext
        {
            /// <summary>The queue of work items.</summary>
            private readonly BlockingCollection<KeyValuePair<SendOrPostCallback, object>> m_queue =
                new BlockingCollection<KeyValuePair<SendOrPostCallback, object>>();
            /// <summary>The processing thread.</summary>
            private readonly Thread m_thread = Thread.CurrentThread;
            /// <summary>The number of outstanding operations.</summary>
            private int m_operationCount = 0;
            /// <summary>Whether to track operations m_operationCount.</summary>
            private readonly bool m_trackOperations;

            /// <summary>Initializes the context.</summary>
            /// <param name="trackOperations">Whether to track operation count.</param>
            internal SingleThreadSynchronizationContext(bool trackOperations)
            {
                m_trackOperations = trackOperations;
            }

            /// <summary>Dispatches an asynchronous message to the synchronization context.</summary>
            /// <param name="d">The System.Threading.SendOrPostCallback delegate to call.</param>
            /// <param name="state">The object passed to the delegate.</param>
            public override void Post(SendOrPostCallback d, object state)
            {
                if (d == null) throw new ArgumentNullException("d");
                m_queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
            }

            /// <summary>Not supported.</summary>
            public override void Send(SendOrPostCallback d, object state)
            {
                throw new NotSupportedException("Synchronously sending is not supported.");
            }

            /// <summary>Runs an loop to process all queued work items.</summary>
            public void RunOnCurrentThread()
            {
                foreach (var workItem in m_queue.GetConsumingEnumerable())
                    workItem.Key(workItem.Value);
            }

            /// <summary>Notifies the context that no more work will arrive.</summary>
            public void Complete() { m_queue.CompleteAdding(); }

            /// <summary>Invoked when an async operation is started.</summary>
            public override void OperationStarted()
            {
                if (m_trackOperations)
                    Interlocked.Increment(ref m_operationCount);
            }

            /// <summary>Invoked when an async operation is completed.</summary>
            public override void OperationCompleted()
            {
                if (m_trackOperations &&
                    Interlocked.Decrement(ref m_operationCount) == 0)
                    Complete();
            }
        }
    }
}

Kullanımı:

AsyncPump.Run(() => FooAsync(...));

Asenkron pompanın daha ayrıntılı açıklaması burada bulunabilir .

Artık bu soruya dikkat eden herkese ...

Eğer içeri bakarsanız Microsoft.VisualStudio.Services.WebApidenilen bir sınıf var TaskExtensions. Bu sınıf içinde statik uzantı yöntemini göreceksinizTask.SyncResult() , görev geri dönene kadar iş parçacığını tamamen engelleyen .

Dahili olarak çağırır task.GetAwaiter().GetResult()ancak herhangi çalışmalarına aşırı oluyor oldukça basit olan asyncdönüş olduğunu yöntemle Task, Task<T>ya Task<HttpResponseMessage>... sözdizimsel şeker, bebek ... Babanın Tatlıyı aldım.

Görünüşe göre ...GetAwaiter().GetResult()async kodunu engelleme bağlamında yürütmenin MS-resmi yolu. Kullanım durumum için çok iyi çalışıyor gibi görünüyor.

var result = Task.Run(async () => await configManager.GetConfigurationAsync()).ConfigureAwait(false);

OpenIdConnectConfiguration config = result.GetAwaiter().GetResult();

Veya bunu kullanın:

var result=result.GetAwaiter().GetResult().AccessToken

Eşzamanlı koddan, awaitüzerinde gerekene kadar herhangi bir eşzamansız yöntemi çağırabilirsiniz , bu durumda da işaretlenmelidir async.

Birçok kişinin burada önerdiği gibi, senkronize yönteminizde ortaya çıkan görev için Wait () veya Sonucu çağırabilirsiniz, ancak daha sonra bu yöntemde async'in amacını yenen bir engelleme çağrısı ile sonuçlanırsınız.

Metodunuzu gerçekten yapamıyorsunuz asyncve senkronize yöntemi kilitlemek istemiyorsanız, görevdeki ContinueWith yöntemine parametre olarak geçirerek bir geri çağırma yöntemi kullanmanız gerekecek.

Çok geç kaldığımı biliyorum. Ama benim gibi birinin bunu düzgün, kolay bir şekilde ve başka bir kütüphaneye bağlı kalmadan çözmek istediği durumda.

Aşağıdaki bulundu kod parçasını gelen Ryan

public static class AsyncHelpers
{
    private static readonly TaskFactory taskFactory = new
        TaskFactory(CancellationToken.None,
            TaskCreationOptions.None,
            TaskContinuationOptions.None,
            TaskScheduler.Default);

    /// <summary>
    /// Executes an async Task method which has a void return value synchronously
    /// USAGE: AsyncUtil.RunSync(() => AsyncMethod());
    /// </summary>
    /// <param name="task">Task method to execute</param>
    public static void RunSync(Func<Task> task)
        => taskFactory
            .StartNew(task)
            .Unwrap()
            .GetAwaiter()
            .GetResult();

    /// <summary>
    /// Executes an async Task<T> method which has a T return type synchronously
    /// USAGE: T result = AsyncUtil.RunSync(() => AsyncMethod<T>());
    /// </summary>
    /// <typeparam name="TResult">Return Type</typeparam>
    /// <param name="task">Task<T> method to execute</param>
    /// <returns></returns>
    public static TResult RunSync<TResult>(Func<Task<TResult>> task)
        => taskFactory
            .StartNew(task)
            .Unwrap()
            .GetAwaiter()
            .GetResult();
}

o zaman böyle diyebilirsin

var t = AsyncUtil.RunSync<T>(() => AsyncMethod<T>());

Saatlerce farklı yöntemleri denedikten sonra, az ya da çok başarılı bir şekilde bitirdim. Sonuç alırken bir kilitlenmeyle bitmez ve aynı zamanda sarılmış olanı değil, orijinal istisnayı alır ve atar.

private ReturnType RunSync()
{
  var task = Task.Run(async () => await myMethodAsync(agency));
  if (task.IsFaulted && task.Exception != null)
  {
    throw task.Exception;
  }

  return task.Result;
}

Yeni bir iş parçacığından çağrılabilir (iş parçacığı havuzundan DEĞİL!):

public static class SomeHelperClass
{ 
       public static T Result<T>(Func<T> func)
        {
            return Task.Factory.StartNew<T>(
                  () => func()
                , TaskCreationOptions.LongRunning
                ).Result;
        }
}
...
content = SomeHelperClass.Result<string>(
  () => response.Content.ReadAsStringAsync().Result
  );

Bu windows zaman uyumsuz yöntemlerinin AsTask () adı verilen şık bir yöntemi vardır. Bu yöntem, yöntemin kendisini bir görev olarak döndürmesini sağlamak için kullanabilirsiniz, böylece Wait () öğesini el ile çağırabilirsiniz.

Örneğin, bir Windows Phone 8 Silverlight uygulamasında aşağıdakileri yapabilirsiniz:

private void DeleteSynchronous(string path)
{
    StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
    Task t = localFolder.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask();
    t.Wait();
}

private void FunctionThatNeedsToBeSynchronous()
{
    // Do some work here
    // ....

    // Delete something in storage synchronously
    DeleteSynchronous("pathGoesHere");

    // Do other work here 
    // .....
}

Bu yardımcı olur umarım!

Çalıştırmak istiyorsanız Senkronizasyon

MethodAsync().RunSynchronously()

   //Example from non UI thread -    
   private void SaveAssetAsDraft()
    {
        SaveAssetDataAsDraft();
    }
    private async Task<bool> SaveAssetDataAsDraft()
    {
       var id = await _assetServiceManager.SavePendingAssetAsDraft();
       return true;   
    }
   //UI Thread - 
   var result = Task.Run(() => SaveAssetDataAsDraft().Result).Result;