c# - WCF 自定义端点行为中字典的 JQuery 并发问题

Question

我会尽力解释这一点。如果我对此感到失望，那么我将删除它并继续前进。也许你们可以给我一些想法。

这是一个网络应用程序。 (C# 4.0(服务器)和 JQuery 1.6.1 客户端)

在客户端，我们设置了一堆文本框，当触发 .focusout 事件时，会触发 AJAX 调用，将数据发送到 WCF 服务。

在服务器端，我们已经创建了一个自定义端点行为，因为我们已经设置了一些安全性内容，因此我们可以在进行这些 AJAX 调用时获取用户信息(这对我们来说很好，所以我不需要设置帮助。)

当我在 JQuery 中发挥创意时，问题就来了，比如如果我想告诉一堆框立即更新(即使它是 2 个文本框!)

$(".blahblahClass").focusout(); //fires a bunch of AJAX calls

繁荣。我在下面的 JsonAuthCallContextInitializer 中得到一个 System.IndexOutOfRangeException(假设是线程错误)，在这里，它试图在我的 CallContextInitializer 的 BeforeInvoke() 中添加一个键到这个字典:

_PrincipalMap[key] = Thread.CurrentPrincipal;

值得一提的是，我正在从 AfterInvoke()

中的同一个字典中删除一个键

好吧.. 作为一个字典，这可能不是线程安全的。所以我添加了一些 lock。 (您将在下面的代码中看到)

我选择了 ReaderWriterLockSlim，因为我读到 lock 有一些并发问题，而 ReaderWriterLock 也有一些问题。

所以我使用默认的 LockRecursionPolicy 添加了锁(它们在下面的代码中)(这意味着我只是将 ReaderWriterLockSlim 构造函数留空)。

当我再次运行应用程序时，我会得到一个 LockRecursionException(在此模式下持有写锁可能无法获取读锁)

将 LockRecursionPolicy.SupportsRecursion 放入 ReaderWriterLockSlim 构造函数中使异常消失，不幸的是，并不是我网页中的所有文本框都更新了..

我的首要任务(我今天将要尝试的)可能是使字典本身 线程安全。像这样:What's the best way of implementing a thread-safe Dictionary?

但我不相信它会解决这里的问题。

更新:所以我尝试了一些其他的东西。我决定使用 ConcurrentDictionary，我什至决定了到底是什么，并摆脱了 AfterInvoke() 中的 .Remove。没有骰子。它基本上要么抑制错误，并且 .html 页面上只有一个文本框会更新，要么在 BeforeInvoke() 中崩溃，如果你有多个文本框更新

仅供引用，静态字典是有意的

建议？ (下面的适用行为代码)

        public class JsonAuthEndpointBehavior : IEndpointBehavior
        {
            private string _key;

            public JsonAuthEndpointBehavior(string key)
            {
                if (key == null) throw new ArgumentNullException("key");

                _key = key;
            }

            public void ApplyDispatchBehavior(ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.EndpointDispatcher endpointDispatcher)
            {
                var jsonAuthCallContextInitializer = new JsonAuthCallContextInitializer(_key);

                foreach (var operation in endpointDispatcher.DispatchRuntime.Operations)
                {
                    operation.CallContextInitializers.Add(jsonAuthCallContextInitializer);
                }
            }

            protected void AddServerErrorHandlers(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
            {
                // Do nothing
            }

            public void AddBindingParameters(ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
            {
                // Do nothing
            }

            public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
            {
                // Do nothing
            }

            public void Validate(ServiceEndpoint endpoint)
            {
                // Do nothing
            }
        }


  public class JsonAuthCallContextInitializer : ICallContextInitializer
    {
        private readonly string _key;
        private static readonly Dictionary<int, IPrincipal> _PrincipalMap = new Dictionary<int, IPrincipal>();
        private readonly ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);

        public JsonAuthCallContextInitializer(string key)
        {
            if (key == null) throw new ArgumentNullException("key");

            _key = key;
        }

        public object BeforeInvoke(InstanceContext instanceContext, IClientChannel channel, Message message)
        {
            if (WebOperationContext.Current == null)
                throw new NotSupportedException("JSON Authentication call context initializer requires HTTP");

            if (Thread.CurrentPrincipal != null)
            {
                var key = Thread.CurrentThread.ManagedThreadId;

                cacheLock.EnterReadLock();
                try
                {
                    //LockRecursionException here
                    _PrincipalMap[key] = Thread.CurrentPrincipal;
                }
                finally
                {
                    cacheLock.ExitReadLock();
                }
            }

            Thread.CurrentPrincipal = new ClaimsPrincipal(new[]
            {
                new ClaimsIdentity((from c in x.Claims select new Claim(blahblah.ToString())).ToArray())
            });

            return null;
        }

        public void AfterInvoke(object correlationState)
        {
            var key = Thread.CurrentThread.ManagedThreadId;

               cacheLock.EnterReadLock();
               try
               {
                   if (!_PrincipalMap.ContainsKey(key)) return;

                   Thread.CurrentPrincipal = _PrincipalMap[key];
               }
               finally
               {
                   cacheLock.ExitReadLock();
               }

               cacheLock.EnterWriteLock();
               try
               {
                    _PrincipalMap.Remove(key);
               }
               catch (Exception)
               {
                   cacheLock.ExitWriteLock();
               }
         }
    }

Answer 1

好吧，我阅读了一些文档，我不确定这是否是问题所在，但看起来您在这里遇到了问题:

            cacheLock.EnterReadLock();
            try
            {
                //LockRecursionException here
                _PrincipalMap[key] = Thread.CurrentPrincipal;
            }
            finally
            {
                cacheLock.ExitReadLock();
            }

它应该是 cacheLock.EnterWriteLock 和 cacheLock.ExitWriteLock，因为您正在添加/更改字典中的值。