/// <summary>
        /// Create a new <see cref="CachingScriptNameResolver"/>.
        /// </summary>
        /// <param name="innerProvider">
        /// The <see cref="IScriptNameResolver"/> that will actually resolve script names. This cannot be null.
        /// </param>
        public CachingScriptNameResolver([WithKey(Factory.NonCachedKey)] IScriptNameResolver innerProvider)
            : base("ScriptNameKey", new CacheFactory {
            MetadataCache = true
        })
        {
            if (innerProvider == null)
            {
                throw new ArgumentNullException("innerProvider");
            }

            InnerProvider = innerProvider;
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Constructor
        /// </summary>
        public ExpressionEngine(IEntityRepository entityRepository, IScriptNameResolver scriptNameResolver)
        {
            if (entityRepository == null)
            {
                throw new ArgumentNullException("entityRepository");
            }
            if (scriptNameResolver == null)
            {
                throw new ArgumentNullException("scriptNameResolver");
            }

            EntityRepository   = entityRepository;
            ScriptNameResolver = scriptNameResolver;
        }
Ejemplo n.º 3
0
        public void ScriptNameResolver_Instance()
        {
            // Check caching resolver
            IScriptNameResolver instance = Factory.ScriptNameResolver;

            Assert.That(instance, Is.InstanceOf <CachingScriptNameResolver>());

            // Check inner resolver
            CachingScriptNameResolver cachingResolver = instance as CachingScriptNameResolver;
            IScriptNameResolver       innerProvider   = cachingResolver.InnerProvider;

            Assert.That(innerProvider, Is.InstanceOf <ScriptNameResolver>());

            // Check inner has graph entity repository
            ScriptNameResolver resolver = innerProvider as ScriptNameResolver;
            Type graphRepositoryType    = Factory.GraphEntityRepository.GetType();

            Assert.That(resolver.EntityRepository, Is.InstanceOf(graphRepositoryType));

            // Check inner has query runner (and not the caching one)
            Type nonCachingQueryRunnerType = Factory.Current.ResolveKeyed <IQueryRunner>(Factory.NonCachedKey).GetType();

            Assert.That(resolver.QueryRunner, Is.InstanceOf(nonCachingQueryRunnerType));
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="entityRepository">Entity repository.</param>
        /// <param name="expressionCompiler">The expression compiler.</param>
        /// <param name="scriptNameResolver">Script name resolver.</param>
        /// <param name="expressionRunner">Expression runner.</param>
        /// <exception cref="System.ArgumentNullException">
        /// entityRepository
        /// or
        /// expressionCompiler
        /// or
        /// expressionRunner
        /// or
        /// scriptNameResolver
        /// </exception>
        public ExternalServices(IEntityRepository entityRepository, IExpressionParseTreeCompiler expressionCompiler, IScriptNameResolver scriptNameResolver, IExpressionRunner expressionRunner)
        {
            if (entityRepository == null)
            {
                throw new ArgumentNullException("entityRepository");
            }
            if (expressionCompiler == null)
            {
                throw new ArgumentNullException("expressionCompiler");
            }
            if (expressionRunner == null)
            {
                throw new ArgumentNullException("expressionRunner");
            }
            if (scriptNameResolver == null)
            {
                throw new ArgumentNullException("scriptNameResolver");
            }

            EntityRepository   = entityRepository;
            ExpressionCompiler = expressionCompiler;
            ExpressionRunner   = expressionRunner;
            ScriptNameResolver = scriptNameResolver;
        }