Exemple #1
0
        private void AddOrUpdateCache(IDbConnection connection, object newState, CacheVariable cacheVar)
        {
            Validate.IsNotNull(nameof(connection), connection);
            SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(connection.ConnectionString);

            AddOrUpdateCache(builder, newState, cacheVar);
        }
Exemple #2
0
        private bool IsAppropriateType(object newState, CacheVariable cacheVar)
        {
            if (newState is DatabaseEngineEdition)
            {
                return(cacheVar == CacheVariable.EngineEdition);
            }

            if (newState is bool)
            {
                return(cacheVar == CacheVariable.IsAzure || cacheVar == CacheVariable.IsCloud);
            }

            return(false);
        }
Exemple #3
0
        public void AddOrUpdateCache(SqlConnectionStringBuilder builder, object newState, CacheVariable cacheVar)
        {
            if (!IsAppropriateType(newState, cacheVar))
            {
                throw new FunctionWrongArgumentTypeException("AddOrUpdateCache: mismatch between expected type of CacheVariable and the type of provided update object");
            }
            Validate.IsNotNull(nameof(builder), builder);
            Validate.IsNotNullOrWhitespaceString(nameof(builder) + ".DataSource", builder.DataSource);
            CachedInfo info;
            bool       hasFound = TryGetCacheValue(builder, out info);

            if (cacheVar == CacheVariable.EngineEdition && hasFound && info.EngineEdition == ConvertState <DatabaseEngineEdition>(newState) ||
                cacheVar == CacheVariable.IsAzure && hasFound && info.IsAzure == ConvertState <bool>(newState))
            {
                // No change needed
                return;
            }
            else
            {
                lock (_cacheLock)
                {
                    // Clean older keys, update info, and add this back into the cache
                    CacheKey key = new CacheKey(builder);
                    CleanupCache(key);

                    if (cacheVar == CacheVariable.EngineEdition)
                    {
                        info.EngineEdition = ConvertState <DatabaseEngineEdition>(newState);
                    }
                    else if (cacheVar == CacheVariable.IsAzure)
                    {
                        info.IsAzure = ConvertState <bool>(newState);
                    }
                    info.LastUpdate = DateTime.UtcNow;
                    _cache.AddOrUpdate(key, info, (k, oldValue) => info);
                }
            }
        }
        internal void AddOrUpdateCache(SqlConnectionStringBuilder builder, bool newState, CacheVariable cacheVar)
        {
            Validate.IsNotNull(nameof(builder), builder);
            Validate.IsNotNullOrWhitespaceString(nameof(builder) + ".DataSource", builder.DataSource);
            CachedInfo info;
            bool       hasFound = TryGetCacheValue(builder, out info);

            if ((cacheVar == CacheVariable.IsSqlDw && hasFound && info.IsSqlDw == newState) ||
                (cacheVar == CacheVariable.IsAzure && hasFound && info.IsAzure == newState))
            {
                // No change needed
                return;
            }
            else
            {
                lock (_cacheLock)
                {
                    // Clean older keys, update info, and add this back into the cache
                    CacheKey key = new CacheKey(builder);
                    CleanupCache(key);

                    if (cacheVar == CacheVariable.IsSqlDw)
                    {
                        info.IsSqlDw = newState;
                    }
                    else if (cacheVar == CacheVariable.IsAzure)
                    {
                        info.IsAzure = newState;
                    }
                    info.LastUpdate = DateTime.UtcNow;
                    _cache.AddOrUpdate(key, info, (k, oldValue) => info);
                }
            }
        }