public async Task <Possible <string, Failure> > PinToCasAsync(CasHash hash, UrgencyHint urgencyHint, Guid activityId)
        {
            using (var eventing = new PinToCasActivity(CompositingCache.EventSource, activityId, this))
            {
                eventing.Start(hash, urgencyHint);

                var result = await m_casSession.PinToCasAsync(hash, urgencyHint, eventing.Id);

                if (result.Succeeded)
                {
                    PinnedToCas.TryAdd(hash, 0);
                }

                return(eventing.Returns(result));
            }
        }
        public Task <Possible <string, Failure> > PinToCasAsync(CasHash hash, UrgencyHint urgencyHint, Guid activityId)
        {
            Contract.Requires(!IsClosed);

            return(Task.Run <Possible <string, Failure> >(() =>
            {
                using (var counter = m_counters.PinToCasCounter())
                {
                    using (var eventing = new PinToCasActivity(BasicFilesystemCache.EventSource, activityId, this))
                    {
                        eventing.Start(hash, urgencyHint);

                        if (!m_pinnedToCas.ContainsKey(hash))
                        {
                            if (!m_cache.CasExists(hash))
                            {
                                counter.PinMiss();
                                var result = new NoCasEntryFailure(m_cache.CacheId, hash);
                                return eventing.Returns(result);
                            }

                            if (!m_pinnedToCas.TryAdd(hash, 0))
                            {
                                counter.PinRaced();
                            }
                        }
                        else
                        {
                            counter.PinDup();
                        }

                        return eventing.Returns(m_cache.CacheId);
                    }
                }
            }));
        }