C# (CSharp) SimpleCompiledDelegateCache示例

示例#1

        public void SimpleCompiledDelegateCache_Basics()
        {
            var cache = new SimpleCompiledDelegateCache();

            Assert.AreEqual(0, cache.Count);

            var f1 = (Func <int>)cache.GetOrAdd(Expression.Lambda(Expression.Constant(42)));

            Assert.AreEqual(42, f1());

            Assert.AreEqual(1, cache.Count);

            var f2 = (Func <int>)cache.GetOrAdd(Expression.Lambda(Expression.Constant(42)));

            Assert.AreEqual(42, f2());
            Assert.AreSame(f1, f2);

            Assert.AreEqual(1, cache.Count);

            var f3 = (Func <int>)cache.GetOrAdd(Expression.Lambda(Expression.Constant(43)));

            Assert.AreEqual(43, f3());

            Assert.AreEqual(2, cache.Count);

            cache.Clear();

            var f4 = (Func <int>)cache.GetOrAdd(Expression.Lambda(Expression.Constant(42)));

            Assert.AreEqual(42, f4());
            Assert.AreNotSame(f1, f4);

            Assert.AreEqual(1, cache.Count);
        }

示例#2

文件： ExpressionPolicyTests.cs 项目： tamirdresher/reaqtor

        public void ExpressionPolicy_PropertyChecks()
        {
            var policy = new ExpressionPolicy();

            Assert.AreSame(DefaultExpressionPolicy.Instance.DelegateCache, policy.DelegateCache);
            Assert.AreSame(DefaultExpressionPolicy.Instance.InMemoryCache, policy.InMemoryCache);
            Assert.AreSame(DefaultExpressionPolicy.Instance.ConstantHoister, policy.ConstantHoister);

            var delegateCache   = new SimpleCompiledDelegateCache();
            var expressionCache = new ExpressionHeap();
            var constantHoister = ConstantHoister.Create(false);

            policy.DelegateCache   = delegateCache;
            policy.InMemoryCache   = expressionCache;
            policy.ConstantHoister = constantHoister;

            Assert.AreSame(delegateCache, policy.DelegateCache);
            Assert.AreSame(expressionCache, policy.InMemoryCache);
            Assert.AreSame(constantHoister, policy.ConstantHoister);

            policy.DelegateCache   = null;
            policy.InMemoryCache   = null;
            policy.ConstantHoister = null;

            Assert.AreSame(DefaultExpressionPolicy.Instance.DelegateCache, policy.DelegateCache);
            Assert.AreSame(DefaultExpressionPolicy.Instance.InMemoryCache, policy.InMemoryCache);
            Assert.AreSame(DefaultExpressionPolicy.Instance.ConstantHoister, policy.ConstantHoister);
        }

示例#3

文件： ExpressionExtensionsTests.cs 项目： tamirdresher/reaqtor

        public void ExpressionExtensions_Evaluate_ArgumentChecking()
        {
#pragma warning disable IDE0034 // Simplify 'default' expression (illustrative of method signature)
            AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionExtensions.Evaluate(default(Expression)), ex => Assert.AreEqual("expression", ex.ParamName));
            AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionExtensions.Evaluate <int>(default(Expression)), ex => Assert.AreEqual("expression", ex.ParamName));
            AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionExtensions.Evaluate <int>(default(Expression <Func <int> >)), ex => Assert.AreEqual("expression", ex.ParamName));

            var cache = new SimpleCompiledDelegateCache();
            AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionExtensions.Evaluate(default(Expression), cache), ex => Assert.AreEqual("expression", ex.ParamName));
            AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionExtensions.Evaluate <int>(default(Expression), cache), ex => Assert.AreEqual("expression", ex.ParamName));
            AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionExtensions.Evaluate <int>(default(Expression <Func <int> >), cache), ex => Assert.AreEqual("expression", ex.ParamName));
            AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionExtensions.Evaluate(Expression.Empty(), cache: null), ex => Assert.AreEqual("cache", ex.ParamName));
            AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionExtensions.Evaluate <int>(Expression.Default(typeof(int)), cache: null), ex => Assert.AreEqual("cache", ex.ParamName));
            AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionExtensions.Evaluate <int>(() => 42, cache: null), ex => Assert.AreEqual("cache", ex.ParamName));
#pragma warning restore IDE0034 // Simplify 'default' expression
        }

示例#4

        public void SimpleCompiledDelegateCache_ArgumentChecking()
        {
            var cache = new SimpleCompiledDelegateCache();

            Assert.ThrowsException <ArgumentNullException>(() => cache.GetOrAdd(expression: null));
        }