[C#] lock 문의 본문 내에서 ‘await’연산자를 사용할 수없는 이유는 무엇입니까?

이것은 http://blogs.msdn.com/b/pfxteam/archive/2012/02/12/10266988.aspx , http://winrtstoragehelper.codeplex.com/ , Windows 8 앱 스토어 및 .net 4.5를 나타냅니다.

여기에 내 각도가 있습니다.

비동기 / 기다리는 언어 기능은 많은 것들을 상당히 쉽게 만들어 주지만 비동기 호출을 사용하기가 쉽지 않은 재진입 시나리오를 소개합니다.

많은 이벤트의 경우 이벤트 핸들러에서 돌아온 후 발생하는 상황에 대한 단서가 없기 때문에 이는 이벤트 핸들러에 특히 해당됩니다. 실제로 발생할 수있는 한 가지는 첫 번째 이벤트 핸들러에서 대기중인 비동기 메소드가 여전히 동일한 스레드의 다른 이벤트 핸들러에서 호출된다는 것입니다.

다음은 Windows 8 App Store 앱에서 발생한 실제 시나리오입니다. 내 응용 프로그램에는 두 가지 프레임이 있습니다. 프레임으로 들어오고 나가는 프레임에서 일부 데이터를 파일 / 저장 장치에로드 / 보호하려고합니다. OnNavigatedTo / From 이벤트는 저장 및로드에 사용됩니다. 저장 및 로딩은 일부 비동기 유틸리티 기능 (예 : http://winrtstoragehelper.codeplex.com/)에 의해 수행됩니다 . )에 . 프레임 1에서 프레임 2로 또는 다른 방향으로 탐색 할 때 비동기로드 및 안전한 작업이 호출되어 대기합니다. 이벤트 핸들러는 비동기 = void를 반환하며 대기 할 수 없습니다.

그러나 유틸리티의 첫 번째 파일 열기 작업 (저장 : 내부 함수라고 함)도 비동기이므로 첫 번째 대기는 프레임 워크에 제어를 반환합니다.이 프레임은 나중에 두 번째 이벤트 핸들러를 통해 다른 유틸리티 (로드)를 호출합니다. 로드는 이제 동일한 파일을 열려고 시도하고 저장 조작을 위해 파일을 지금 여는 경우 ACCESSDENIED 예외로 실패합니다.

나를위한 최소한의 해결책은 using 및 AsyncLock을 통해 파일 액세스를 보호하는 것입니다.

private static readonly AsyncLock m_lock = new AsyncLock();
...

using (await m_lock.LockAsync())
{
    file = await folder.GetFileAsync(fileName);
    IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read);
    using (Stream inStream = Task.Run(() => readStream.AsStreamForRead()).Result)
    {
        return (T)serializer.Deserialize(inStream);
    }
}

그의 잠금은 기본적으로 하나의 잠금으로 유틸리티의 모든 파일 작업을 잠급니다. 이는 불필요하게 강력하지만 내 시나리오에는 잘 작동합니다.

여기 내 테스트 프로젝트가 있습니다 : http://winrtstoragehelper.codeplex.com/ 의 원본 버전에 대한 테스트 호출이있는 Windows 8 앱 스토어 앱과 Stephen Toub의 AsyncLock을 사용하는 수정 된 버전 http : //blogs.msdn. com / b / pfxteam / archive / 2012 / 02 / 12 / 10266988.aspx .

이 링크를 제안해도됩니다 :
http://www.hanselman.com/blog/ComparingTwoTechniquesInNETAsynchronousCoordinationPrimitives.aspx

답변

/// <summary>
///     Demo class for reader/writer lock that supports async/await.
///     For source, see Stephen Taub's brilliant article, "Building Async Coordination
///     Primitives, Part 7: AsyncReaderWriterLock".
/// </summary>
public class AsyncReaderWriterLockDemo
{
    private readonly IAsyncReaderWriterLock _lock = new AsyncReaderWriterLock();

    public async void DemoCode()
    {
        using(var releaser = await _lock.ReaderLockAsync())
        {
            // Insert reads here.
            // Multiple readers can access the lock simultaneously.
        }

        using (var releaser = await _lock.WriterLockAsync())
        {
            // Insert writes here.
            // If a writer is in progress, then readers are blocked.
        }
    }
}

static class Async
{
    public static Task<IDisposable> Lock(object obj)
    {
        return TaskEx.Run(() =>
            {
                var resetEvent = ResetEventFor(obj);

                resetEvent.WaitOne();
                resetEvent.Reset();

                return new ExitDisposable(obj) as IDisposable;
            });
    }

    private static readonly IDictionary<object, WeakReference> ResetEventMap =
        new Dictionary<object, WeakReference>();

    private static ManualResetEvent ResetEventFor(object @lock)
    {
        if (!ResetEventMap.ContainsKey(@lock) ||
            !ResetEventMap[@lock].IsAlive)
        {
            ResetEventMap[@lock] =
                new WeakReference(new ManualResetEvent(true));
        }

        return ResetEventMap[@lock].Target as ManualResetEvent;
    }

    private static void CleanUp()
    {
        ResetEventMap.Where(kv => !kv.Value.IsAlive)
                     .ToList()
                     .ForEach(kv => ResetEventMap.Remove(kv));
    }

    private class ExitDisposable : IDisposable
    {
        private readonly object _lock;

        public ExitDisposable(object @lock)
        {
            _lock = @lock;
        }

        public void Dispose()
        {
            ResetEventFor(_lock).Set();
        }

        ~ExitDisposable()
        {
            CleanUp();
        }
    }
}