public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)
        {
            string cacheKey = this.CreateCacheKey(inputs);

            CachedOperationResult cachedItem       = CacheServiceHelper.Current.Get <CachedOperationResult>(cacheKey);
            CachingUserState      cachingUserState = new CachingUserState
            {
                CacheItem = cachedItem,
                CacheKey  = cacheKey,
                Callback  = callback,
                State     = state
            };

            IAsyncResult originalAsyncResult;

            if (cachedItem != null)
            {
                InvokerDelegate invoker = cachedItem.GetValue;

                object[] notUsed;
                originalAsyncResult = invoker.BeginInvoke(inputs, out notUsed, this.InvokerCallback, cachingUserState);
            }
            else
            {
                originalAsyncResult = _invoker.InvokeBegin(instance, inputs, this.InvokerCallback, cachingUserState);
            }

            return(new CachingAsyncResult(originalAsyncResult, cachingUserState));
        }
        public object InvokeEnd(object instance, out object[] outputs, IAsyncResult asyncResult)
        {
            CachingAsyncResult cachingAsyncResult = asyncResult as CachingAsyncResult;
            CachingUserState   cachingUserState   = cachingAsyncResult.CachingUserState;

            if (cachingUserState.CacheItem == null)
            {
                object result = this.originalInvoker.InvokeEnd(instance, out outputs, cachingAsyncResult.OriginalAsyncResult);
                cachingUserState.CacheItem = new CachedResult {
                    ReturnValue = result, Outputs = outputs
                };
#if Webhosted
                this.GetCache().Insert(cachingUserState.CacheKey, cachingUserState.CacheItem, null, Cache.NoAbsoluteExpiration, TimeSpan.FromSeconds(this.cacheDuration));
#else
                this.GetCache().Add(cachingUserState.CacheKey, cachingUserState.CacheItem, DateTimeOffset.UtcNow.Add(TimeSpan.FromSeconds(this.cacheDuration)));
#endif
                return(result);
            }
            else
            {
                InvokerDelegate invoker = ((System.Runtime.Remoting.Messaging.AsyncResult)cachingAsyncResult.OriginalAsyncResult).AsyncDelegate as InvokerDelegate;
                invoker.EndInvoke(out outputs, cachingAsyncResult.OriginalAsyncResult);
                return(cachingUserState.CacheItem.ReturnValue);
            }
        }
        public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)
        {
#if Webhosted
            Cache cache = GetCache();
#else
            ObjectCache cache = this.GetCache();
#endif
            string           cacheKey         = this.CreateCacheKey(inputs);
            CachedResult     cacheItem        = cache[cacheKey] as CachedResult;
            CachingUserState cachingUserState = new CachingUserState
            {
                CacheItem            = cacheItem,
                CacheKey             = cacheKey,
                OriginalUserCallback = callback,
                OriginalUserState    = state
            };

            IAsyncResult originalAsyncResult;
            if (cacheItem != null)
            {
                InvokerDelegate invoker = cacheItem.GetValue;
                object[]        dummy;
                originalAsyncResult = invoker.BeginInvoke(inputs, out dummy, this.InvokerCallback, cachingUserState);
            }
            else
            {
                originalAsyncResult = this.originalInvoker.InvokeBegin(instance, inputs, this.InvokerCallback, cachingUserState);
            }

            return(new CachingAsyncResult(originalAsyncResult, cachingUserState));
        }
Esempio n. 4
0
        private static T AdaptToHost <T>(AddInToken pipeline, IContract addInContract)
        {
            if (addInContract == null)
            {
                throw new ArgumentNullException("addInContract");
            }
            System.Diagnostics.Contracts.Contract.EndContractBlock();

            ContractComponent contract    = pipeline._contract;
            HostAdapter       hostAdapter = pipeline._hostAdapter;

            Type hostAdapterType;
            Type contractType;

            LoadContractAndHostAdapter(contract, hostAdapter, out contractType, out hostAdapterType);

            int?temporaryToken = null;

            try
            {
                temporaryToken = addInContract.AcquireLifetimeToken();

                // This assembly resolve event exists to:
                //    1) To upgrade the contract assembly from the LoadFrom context to
                //       the default loader context
                ResolverHelper      resolver         = new ResolverHelper(pipeline);
                ResolveEventHandler assemblyResolver = new ResolveEventHandler(resolver.ResolveAssemblyForHostAdapter);
                AppDomain.CurrentDomain.AssemblyResolve += assemblyResolver;

                // Create the Host Adapter, which is a subclass of the Host Add-In View.
                // Pass the contract implementation to this constructor, using a
                // transparent proxy to the real type.  Detect common errors here.
                InvokerDelegate myInvokerDelegate = CreateConsInvoker(hostAdapterType, contractType);

                T hav;
                try
                {
                    hav = (T)myInvokerDelegate(addInContract);
                }
                catch (ArgumentException e)
                {
                    CheckForLoaderContextProblems(contract, pipeline._addinAdapter, e);
                    throw;
                }
                finally
                {
                    AppDomain.CurrentDomain.AssemblyResolve -= assemblyResolver;
                }

                return(hav);
            }
            finally
            {
                if (temporaryToken != null && addInContract != null)
                {
                    addInContract.RevokeLifetimeToken((int)temporaryToken);
                }
            }
        }
        public void BeginInvoke()
        {
            this.invoker = PrintTime;
            invoker += Statistics;

            while (true)
            {
                invoker();
                this.calls++;
                Thread.Sleep(this.T*1000);
            }
        }
Esempio n. 6
0
        internal static T ActivateHostAdapter <T>(PartialToken pipeline, IContract addIn)
        {
            if (pipeline == null)
            {
                throw new ArgumentNullException("pipeline");
            }
            if (addIn == null)
            {
                throw new ArgumentNullException("addIn");
            }
            System.Diagnostics.Contracts.Contract.EndContractBlock();

            ContractComponent contract    = pipeline._contract;
            HostAdapter       hostAdapter = pipeline._hostAdapter;

            Type hostAdapterType;
            Type contractType;

            LoadContractAndHostAdapter(contract, hostAdapter, out contractType, out hostAdapterType);

            // This assembly resolve event exists to:
            //    1) To upgrade the contract assembly from the LoadFrom context to
            //       the default loader context
            ResolverHelper      resolver         = new ResolverHelper(contract);
            ResolveEventHandler assemblyResolver = new ResolveEventHandler(resolver.ResolveAssemblyForHostAdapter);

            AppDomain.CurrentDomain.AssemblyResolve += assemblyResolver;

            T hav;

            InvokerDelegate myInvokerDelegate = CreateConsInvoker(hostAdapterType, contractType);

            try
            {
                hav = (T)myInvokerDelegate(addIn);
            }
            catch (ArgumentException e)
            {
                CheckForLoaderContextProblems(contract, pipeline._addinAdapter, e);
                throw;
            }
            finally
            {
                AppDomain.CurrentDomain.AssemblyResolve -= assemblyResolver;
            }

            return(hav);
        }
        public object InvokeEnd(object instance, out object[] outputs, IAsyncResult asyncResult)
        {
            CachingAsyncResult result = asyncResult as CachingAsyncResult;
            CachingUserState   state  = result.CachingUserState;

            if (state.CacheItem == null)
            {
                object data = _invoker.InvokeEnd(instance, out outputs, result.OriginalAsyncResult);
                state.CacheItem = new CachedOperationResult {
                    Data = data, Outputs = outputs
                };

                CacheServiceHelper.Current.Add(state.CacheKey, state.CacheItem, TimeSpan.FromSeconds(_cacheDuration));

                return(data);
            }
            else
            {
                InvokerDelegate invoker = ((AsyncResult)result.OriginalAsyncResult).AsyncDelegate as InvokerDelegate;
                invoker.EndInvoke(out outputs, result.OriginalAsyncResult);

                return(state.CacheItem.Data);
            }
        }