diff --git a/src/Umbraco.Core/Persistence/Caching/RuntimeCacheProvider.cs b/src/Umbraco.Core/Persistence/Caching/RuntimeCacheProvider.cs index f76303458a..ac9c9f5a65 100644 --- a/src/Umbraco.Core/Persistence/Caching/RuntimeCacheProvider.cs +++ b/src/Umbraco.Core/Persistence/Caching/RuntimeCacheProvider.cs @@ -1,260 +1,238 @@ -using System; -using System.Collections; -using System.Collections.Concurrent; -using System.Collections.Generic; -using System.Linq; -using System.Runtime.Caching; -using System.Threading; -using System.Web; -using Umbraco.Core.Models.EntityBase; +//using System; +//using System.Collections; +//using System.Collections.Concurrent; +//using System.Collections.Generic; +//using System.Linq; +//using System.Runtime.Caching; +//using System.Threading; +//using System.Web; +//using Umbraco.Core.Models.EntityBase; -namespace Umbraco.Core.Persistence.Caching -{ - //TODO: Remove this singleton! +//namespace Umbraco.Core.Persistence.Caching +//{ +// //TODO: Remove this singleton! - /// - /// The Runtime Cache provider looks up objects in the Runtime cache for fast retrival - /// - /// - /// - /// If a web session is detected then the HttpRuntime.Cache will be used for the runtime cache, otherwise a custom - /// MemoryCache instance will be used. It is important to use the HttpRuntime.Cache when a web session is detected so - /// that the memory management of cache in IIS can be handled appopriately. - /// - /// When a web sessions is detected we will pre-fix all HttpRuntime.Cache entries so that when we clear it we are only - /// clearing items that have been inserted by this provider. - /// - /// NOTE: These changes are all temporary until we finalize the ApplicationCache implementation which will support static cache, runtime cache - /// and request based cache which will all live in one central location so it is easily managed. - /// - /// Also note that we don't always keep checking if HttpContext.Current == null and instead check for _memoryCache != null. This is because - /// when there are async requests being made even in the context of a web request, the HttpContext.Current will be null but the HttpRuntime.Cache will - /// always be available. - /// - /// TODO: Each item that get's added to this cache will be a clone of the original with it's dirty properties reset, and every item that is resolved from the cache - /// is a clone of the item that is in there, otherwise we end up with thread safety issues since multiple thread would be working on the exact same entity at the same time. - /// - /// - internal sealed class RuntimeCacheProvider : IRepositoryCacheProvider - { - #region Singleton +// /// +// /// The Runtime Cache provider looks up objects in the Runtime cache for fast retrival +// /// +// /// +// /// +// /// If a web session is detected then the HttpRuntime.Cache will be used for the runtime cache, otherwise a custom +// /// MemoryCache instance will be used. It is important to use the HttpRuntime.Cache when a web session is detected so +// /// that the memory management of cache in IIS can be handled appopriately. +// /// +// /// When a web sessions is detected we will pre-fix all HttpRuntime.Cache entries so that when we clear it we are only +// /// clearing items that have been inserted by this provider. +// /// +// /// NOTE: These changes are all temporary until we finalize the ApplicationCache implementation which will support static cache, runtime cache +// /// and request based cache which will all live in one central location so it is easily managed. +// /// +// /// Also note that we don't always keep checking if HttpContext.Current == null and instead check for _memoryCache != null. This is because +// /// when there are async requests being made even in the context of a web request, the HttpContext.Current will be null but the HttpRuntime.Cache will +// /// always be available. +// /// +// /// +// internal sealed class RuntimeCacheProvider : IRepositoryCacheProvider +// { +// #region Singleton - private static readonly Lazy lazy = new Lazy(() => new RuntimeCacheProvider()); +// private static readonly Lazy lazy = new Lazy(() => new RuntimeCacheProvider()); - public static RuntimeCacheProvider Current { get { return lazy.Value; } } +// public static RuntimeCacheProvider Current { get { return lazy.Value; } } - //internal for testing! - though I'm not a huge fan of these being singletons! - internal RuntimeCacheProvider() - { - if (HttpContext.Current == null) - { - _memoryCache = new MemoryCache("in-memory"); - } - } +// //internal for testing! - though I'm not a huge fan of these being singletons! +// internal RuntimeCacheProvider() +// { +// if (HttpContext.Current == null) +// { +// _memoryCache = new MemoryCache("in-memory"); +// } +// } - #endregion +// #endregion - //TODO Save this in cache as well, so its not limited to a single server usage - private readonly ConcurrentHashSet _keyTracker = new ConcurrentHashSet(); - private ObjectCache _memoryCache; - private static readonly ReaderWriterLockSlim ClearLock = new ReaderWriterLockSlim(); +// //TODO Save this in cache as well, so its not limited to a single server usage +// private readonly ConcurrentHashSet _keyTracker = new ConcurrentHashSet(); +// private ObjectCache _memoryCache; +// private static readonly ReaderWriterLockSlim ClearLock = new ReaderWriterLockSlim(); - public IEntity GetById(Type type, Guid id) - { - var key = GetCompositeId(type, id); - var item = _memoryCache != null - ? _memoryCache.Get(key) - : HttpRuntime.Cache.Get(key); - var result = item as IEntity; - if (result == null) - { - //ensure the key doesn't exist anymore in the tracker - _keyTracker.Remove(key); - return null; - } +// public IEntity GetById(Type type, Guid id) +// { +// var key = GetCompositeId(type, id); +// var item = _memoryCache != null +// ? _memoryCache.Get(key) +// : HttpRuntime.Cache.Get(key); +// var result = item as IEntity; +// if (result == null) +// { +// //ensure the key doesn't exist anymore in the tracker +// _keyTracker.Remove(key); +// return null; +// } - //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259 - return (IEntity)result.DeepClone(); - } +// //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259 +// return (IEntity)result.DeepClone(); +// } - public IEnumerable GetByIds(Type type, List ids) - { - var collection = new List(); - foreach (var guid in ids) - { - var key = GetCompositeId(type, guid); - var item = _memoryCache != null - ? _memoryCache.Get(key) - : HttpRuntime.Cache.Get(key); - var result = item as IEntity; - if (result == null) - { - //ensure the key doesn't exist anymore in the tracker - _keyTracker.Remove(key); - } - else - { - //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259 - collection.Add((IEntity)result.DeepClone()); - } - } - return collection; - } +// public IEnumerable GetByIds(Type type, List ids) +// { +// var collection = new List(); +// foreach (var guid in ids) +// { +// var key = GetCompositeId(type, guid); +// var item = _memoryCache != null +// ? _memoryCache.Get(key) +// : HttpRuntime.Cache.Get(key); +// var result = item as IEntity; +// if (result == null) +// { +// //ensure the key doesn't exist anymore in the tracker +// _keyTracker.Remove(key); +// } +// else +// { +// //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259 +// collection.Add((IEntity)result.DeepClone()); +// } +// } +// return collection; +// } - public IEnumerable GetAllByType(Type type) - { - var collection = new List(); - foreach (var key in _keyTracker) - { - if (key.StartsWith(string.Format("{0}{1}-", CacheItemPrefix, type.Name))) - { - var item = _memoryCache != null - ? _memoryCache.Get(key) - : HttpRuntime.Cache.Get(key); +// public IEnumerable GetAllByType(Type type) +// { +// var collection = new List(); +// foreach (var key in _keyTracker) +// { +// if (key.StartsWith(string.Format("{0}{1}-", CacheItemPrefix, type.Name))) +// { +// var item = _memoryCache != null +// ? _memoryCache.Get(key) +// : HttpRuntime.Cache.Get(key); - var result = item as IEntity; - if (result == null) - { - //ensure the key doesn't exist anymore in the tracker - _keyTracker.Remove(key); - } - else - { - //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259 - collection.Add((IEntity)result.DeepClone()); - } - } - } - return collection; - } +// var result = item as IEntity; +// if (result == null) +// { +// //ensure the key doesn't exist anymore in the tracker +// _keyTracker.Remove(key); +// } +// else +// { +// //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259 +// collection.Add((IEntity)result.DeepClone()); +// } +// } +// } +// return collection; +// } - public void Save(Type type, IEntity entity) - { - //IMPORTANT: we must clone to store, see: http://issues.umbraco.org/issue/U4-4259 - var clone = (IEntity)entity.DeepClone(); +// public void Save(Type type, IEntity entity) +// { +// //IMPORTANT: we must clone to store, see: http://issues.umbraco.org/issue/U4-4259 +// var clone = (IEntity)entity.DeepClone(); - var key = GetCompositeId(type, clone.Id); +// var key = GetCompositeId(type, clone.Key); - _keyTracker.TryAdd(key); +// _keyTracker.TryAdd(key); - //NOTE: Before we were checking if it already exists but the MemoryCache.Set handles this implicitly and does - // an add or update, same goes for HttpRuntime.Cache.Insert. +// //NOTE: Before we were checking if it already exists but the MemoryCache.Set handles this implicitly and does +// // an add or update, same goes for HttpRuntime.Cache.Insert. - if (_memoryCache != null) - { - _memoryCache.Set(key, clone, new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(5) }); - } - else - { - HttpRuntime.Cache.Insert(key, clone, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(5)); - } - } +// if (_memoryCache != null) +// { +// _memoryCache.Set(key, clone, new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(5) }); +// } +// else +// { +// HttpRuntime.Cache.Insert(key, clone, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(5)); +// } +// } - public void Delete(Type type, IEntity entity) - { - var key = GetCompositeId(type, entity.Id); - if (_memoryCache != null) - { - _memoryCache.Remove(key); - } - else - { - HttpRuntime.Cache.Remove(key); - } +// public void Delete(Type type, IEntity entity) +// { +// var key = GetCompositeId(type, entity.Key); +// if (_memoryCache != null) +// { +// _memoryCache.Remove(key); +// } +// else +// { +// HttpRuntime.Cache.Remove(key); +// } - _keyTracker.Remove(key); - } +// _keyTracker.Remove(key); +// } + +// /// +// /// Clear cache by type +// /// +// /// +// public void Clear(Type type) +// { +// using (new WriteLock(ClearLock)) +// { +// var keys = new string[_keyTracker.Count]; +// _keyTracker.CopyTo(keys, 0); +// var keysToRemove = new List(); +// foreach (var key in keys.Where(x => x.StartsWith(string.Format("{0}{1}-", CacheItemPrefix, type.Name)))) +// { +// _keyTracker.Remove(key); +// keysToRemove.Add(key); +// } +// foreach (var key in keysToRemove) +// { +// if (_memoryCache != null) +// { +// _memoryCache.Remove(key); +// } +// else +// { +// HttpRuntime.Cache.Remove(key); +// } +// } +// } +// } - public void Delete(Type type, int entityId) - { - var key = GetCompositeId(type, entityId); - if (_memoryCache != null) - { - _memoryCache.Remove(key); - } - else - { - HttpRuntime.Cache.Remove(key); - } +// public void Clear() +// { +// using (new WriteLock(ClearLock)) +// { +// _keyTracker.Clear(); - _keyTracker.Remove(key); - } +// ClearDataCache(); +// } +// } - /// - /// Clear cache by type - /// - /// - public void Clear(Type type) - { - using (new WriteLock(ClearLock)) - { - var keys = new string[_keyTracker.Count]; - _keyTracker.CopyTo(keys, 0); - var keysToRemove = new List(); - foreach (var key in keys.Where(x => x.StartsWith(string.Format("{0}{1}-", CacheItemPrefix, type.Name)))) - { - _keyTracker.Remove(key); - keysToRemove.Add(key); - } - foreach (var key in keysToRemove) - { - if (_memoryCache != null) - { - _memoryCache.Remove(key); - } - else - { - HttpRuntime.Cache.Remove(key); - } - } - } - } +// //DO not call this unless it's for testing since it clears the data cached but not the keys +// internal void ClearDataCache() +// { +// if (_memoryCache != null) +// { +// _memoryCache.DisposeIfDisposable(); +// _memoryCache = new MemoryCache("in-memory"); +// } +// else +// { +// foreach (DictionaryEntry c in HttpRuntime.Cache) +// { +// if (c.Key is string && ((string)c.Key).InvariantStartsWith(CacheItemPrefix)) +// { +// if (HttpRuntime.Cache[(string)c.Key] == null) return; +// HttpRuntime.Cache.Remove((string)c.Key); +// } +// } +// } +// } - public void Clear() - { - using (new WriteLock(ClearLock)) - { - _keyTracker.Clear(); +// /// +// /// We prefix all cache keys with this so that we know which ones this class has created when +// /// using the HttpRuntime cache so that when we clear it we don't clear other entries we didn't create. +// /// +// private const string CacheItemPrefix = "umbrtmche_"; - ClearDataCache(); - } - } +// private string GetCompositeId(Type type, Guid id) +// { +// return string.Format("{0}{1}-{2}", CacheItemPrefix, type.Name, id); +// } - //DO not call this unless it's for testing since it clears the data cached but not the keys - internal void ClearDataCache() - { - if (_memoryCache != null) - { - _memoryCache.DisposeIfDisposable(); - _memoryCache = new MemoryCache("in-memory"); - } - else - { - foreach (DictionaryEntry c in HttpRuntime.Cache) - { - if (c.Key is string && ((string)c.Key).InvariantStartsWith(CacheItemPrefix)) - { - if (HttpRuntime.Cache[(string)c.Key] == null) return; - HttpRuntime.Cache.Remove((string)c.Key); - } - } - } - } - - /// - /// We prefix all cache keys with this so that we know which ones this class has created when - /// using the HttpRuntime cache so that when we clear it we don't clear other entries we didn't create. - /// - private const string CacheItemPrefix = "umbrtmche_"; - - private string GetCompositeId(Type type, Guid id) - { - return string.Format("{0}{1}-{2}", CacheItemPrefix, type.Name, id); - } - - private string GetCompositeId(Type type, int id) - { - return string.Format("{0}{1}-{2}", CacheItemPrefix, type.Name, id.ToGuid()); - } - } -} \ No newline at end of file +// } +//} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs index a4748c4e7b..d961cfed6b 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs @@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories internal class ContentPreviewRepository : PetaPocoRepositoryBase> where TContent : IContentBase { - public ContentPreviewRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + public ContentPreviewRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs index 16937eeb79..c335fd25a6 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs @@ -19,6 +19,7 @@ using Umbraco.Core.Persistence.Caching; using Umbraco.Core.Persistence.DatabaseModelDefinitions; using Umbraco.Core.Persistence.Factories; using Umbraco.Core.Persistence.Querying; +using Umbraco.Core.Cache; using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Persistence.UnitOfWork; @@ -35,8 +36,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly CacheHelper _cacheHelper; private readonly ContentPreviewRepository _contentPreviewRepository; private readonly ContentXmlRepository _contentXmlRepository; - - public ContentRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, CacheHelper cacheHelper) + + public ContentRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, CacheHelper cacheHelper) : base(work, cache, logger) { if (contentTypeRepository == null) throw new ArgumentNullException("contentTypeRepository"); @@ -46,8 +47,8 @@ namespace Umbraco.Core.Persistence.Repositories _templateRepository = templateRepository; _tagRepository = tagRepository; _cacheHelper = cacheHelper; - _contentPreviewRepository = new ContentPreviewRepository(work, NullCacheProvider.Current, logger); - _contentXmlRepository = new ContentXmlRepository(work, NullCacheProvider.Current, logger); + _contentPreviewRepository = new ContentPreviewRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger); + _contentXmlRepository = new ContentXmlRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger); EnsureUniqueNaming = true; } @@ -590,10 +591,11 @@ namespace Umbraco.Core.Persistence.Repositories // then we can use that entity. Otherwise if it is not published (which can be the case // because we only store the 'latest' entries in the cache which might not be the published // version) - var fromCache = TryGetFromCache(dto.NodeId); - if (fromCache.Success && fromCache.Result.Published) + var fromCache = RepositoryCache.RuntimeCache.GetCacheItem(GetCacheIdKey(dto.NodeId)); + //var fromCache = TryGetFromCache(dto.NodeId); + if (fromCache != null && fromCache.Published) { - yield return fromCache.Result; + yield return fromCache; } else { diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs index 7b78ed79f7..6867194db6 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs @@ -27,8 +27,8 @@ namespace Umbraco.Core.Persistence.Repositories internal abstract class ContentTypeBaseRepository : PetaPocoRepositoryBase where TEntity : class, IContentTypeComposition { - - protected ContentTypeBaseRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + + protected ContentTypeBaseRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs index ee415884fe..07e57b9e28 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs @@ -21,7 +21,7 @@ namespace Umbraco.Core.Persistence.Repositories { private readonly ITemplateRepository _templateRepository; - public ContentTypeRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger, ITemplateRepository templateRepository) + public ContentTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ITemplateRepository templateRepository) : base(work, cache, logger) { _templateRepository = templateRepository; diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs index 84c85d1ddf..75700ff4ce 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs @@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories internal class ContentXmlRepository : PetaPocoRepositoryBase> where TContent : IContentBase { - public ContentXmlRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + public ContentXmlRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs index 21255964d7..84fc065598 100644 --- a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs @@ -28,13 +28,13 @@ namespace Umbraco.Core.Persistence.Repositories private readonly IContentTypeRepository _contentTypeRepository; private readonly DataTypePreValueRepository _preValRepository; - public DataTypeDefinitionRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, CacheHelper cacheHelper, ILogger logger, + public DataTypeDefinitionRepository(IDatabaseUnitOfWork work, CacheHelper cache, CacheHelper cacheHelper, ILogger logger, IContentTypeRepository contentTypeRepository) : base(work, cache, logger) { _cacheHelper = cacheHelper; _contentTypeRepository = contentTypeRepository; - _preValRepository = new DataTypePreValueRepository(work, NullCacheProvider.Current, logger); + _preValRepository = new DataTypePreValueRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger); } private readonly ReaderWriterLockSlim _locker = new ReaderWriterLockSlim(); @@ -438,7 +438,7 @@ AND umbracoNode.id <> @id", /// private class DataTypePreValueRepository : PetaPocoRepositoryBase { - public DataTypePreValueRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + public DataTypePreValueRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs index c77bc9624a..03f7518dfc 100644 --- a/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs @@ -9,6 +9,7 @@ using Umbraco.Core.Persistence.Caching; using Umbraco.Core.Persistence.Factories; using Umbraco.Core.Persistence.Querying; using Umbraco.Core.Persistence.Relators; +using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Persistence.UnitOfWork; namespace Umbraco.Core.Persistence.Repositories @@ -18,13 +19,15 @@ namespace Umbraco.Core.Persistence.Repositories /// internal class DictionaryRepository : PetaPocoRepositoryBase, IDictionaryRepository { + private readonly ISqlSyntaxProvider _syntaxProvider; private readonly ILanguageRepository _languageRepository; - - public DictionaryRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger, ILanguageRepository languageRepository) + + public DictionaryRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider syntaxProvider, ILanguageRepository languageRepository) : base(work, cache, logger) - { - _languageRepository = languageRepository; - } + { + _syntaxProvider = syntaxProvider; + _languageRepository = languageRepository; + } #region Overrides of RepositoryBase @@ -38,19 +41,7 @@ namespace Umbraco.Core.Persistence.Repositories if (dto == null) return null; - var factory = new DictionaryItemFactory(); - var entity = factory.BuildEntity(dto); - - var list = new List(); - foreach (var textDto in dto.LanguageTextDtos) - { - var language = _languageRepository.Get(textDto.LanguageId); - if (language == null) - continue; - var translationFactory = new DictionaryTranslationFactory(dto.UniqueId, language); - list.Add(translationFactory.BuildEntity(textDto)); - } - entity.Translations = list; + var entity = ConvertFromDto(dto); //on initial construction we don't want to have dirty properties tracked // http://issues.umbraco.org/issue/U4-1946 @@ -61,21 +52,14 @@ namespace Umbraco.Core.Persistence.Repositories protected override IEnumerable PerformGetAll(params int[] ids) { + var sql = GetBaseQuery(false).Where("cmsDictionary.pk > 0"); if (ids.Any()) { - foreach (var id in ids) - { - yield return Get(id); - } - } - else - { - var dtos = Database.Fetch("WHERE pk > 0"); - foreach (var dto in dtos) - { - yield return Get(dto.PrimaryKey); - } + sql.Where("cmsDictionary.pk in (@ids)", new { ids = ids }); } + + return Database.Fetch(new DictionaryLanguageTextRelator().Map, sql) + .Select(ConvertFromDto); } protected override IEnumerable PerformGetByQuery(IQuery query) @@ -85,12 +69,8 @@ namespace Umbraco.Core.Persistence.Repositories var sql = translator.Translate(); sql.OrderBy(x => x.UniqueId); - var dtos = Database.Fetch(new DictionaryLanguageTextRelator().Map, sql); - - foreach (var dto in dtos) - { - yield return Get(dto.PrimaryKey); - } + return Database.Fetch(new DictionaryLanguageTextRelator().Map, sql) + .Select(ConvertFromDto); } #endregion @@ -189,6 +169,10 @@ namespace Umbraco.Core.Persistence.Repositories } entity.ResetDirtyProperties(); + + //Clear the cache entries that exist by uniqueid/item key + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.ItemKey)); + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.Key)); } protected override void PersistDeletedItem(IDictionaryItem entity) @@ -196,8 +180,11 @@ namespace Umbraco.Core.Persistence.Repositories RecursiveDelete(entity.Key); Database.Delete("WHERE UniqueId = @Id", new { Id = entity.Key}); - Database.Delete("WHERE id = @Id", new { Id = entity.Key }); + + //Clear the cache entries that exist by uniqueid/item key + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.ItemKey)); + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.Key)); } private void RecursiveDelete(Guid parentId) @@ -209,9 +196,126 @@ namespace Umbraco.Core.Persistence.Repositories Database.Delete("WHERE UniqueId = @Id", new { Id = dto.UniqueId }); Database.Delete("WHERE id = @Id", new { Id = dto.UniqueId }); + + //Clear the cache entries that exist by uniqueid/item key + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(dto.Key)); + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(dto.UniqueId)); } } #endregion + + protected IDictionaryItem ConvertFromDto(DictionaryDto dto) + { + var factory = new DictionaryItemFactory(); + var entity = factory.BuildEntity(dto); + + var list = new List(); + foreach (var textDto in dto.LanguageTextDtos) + { + var language = _languageRepository.Get(textDto.LanguageId); + if (language == null) + continue; + var translationFactory = new DictionaryTranslationFactory(dto.UniqueId, language); + list.Add(translationFactory.BuildEntity(textDto)); + } + entity.Translations = list; + + return entity; + } + + public IDictionaryItem Get(Guid uniqueId) + { + var uniqueIdRepo = new DictionaryByUniqueIdRepository(this, UnitOfWork, RepositoryCache, Logger); + return uniqueIdRepo.Get(uniqueId); + } + + public IDictionaryItem Get(string key) + { + var keyRepo = new DictionaryByKeyRepository(this, UnitOfWork, RepositoryCache, Logger); + return keyRepo.Get(key); + } + + private class DictionaryByUniqueIdRepository : SimpleGetRepository + { + private readonly DictionaryRepository _dictionaryRepository; + + public DictionaryByUniqueIdRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) + : base(work, cache, logger) + { + _dictionaryRepository = dictionaryRepository; + } + + protected override IEnumerable PerformFetch(Sql sql) + { + return Database.Fetch(new DictionaryLanguageTextRelator().Map, sql); + } + + protected override Sql GetBaseQuery(bool isCount) + { + return _dictionaryRepository.GetBaseQuery(isCount); + } + + protected override string GetBaseWhereClause() + { + return "cmsDictionary.id = @Id"; + } + + protected override IDictionaryItem ConvertToEntity(DictionaryDto dto) + { + return _dictionaryRepository.ConvertFromDto(dto); + } + + protected override object GetBaseWhereClauseArguments(Guid id) + { + return new {Id = id}; + } + + protected override string GetWhereInClauseForGetAll() + { + return "cmsDictionary.id in (@ids)"; + } + } + + private class DictionaryByKeyRepository : SimpleGetRepository + { + private readonly DictionaryRepository _dictionaryRepository; + + public DictionaryByKeyRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) + : base(work, cache, logger) + { + _dictionaryRepository = dictionaryRepository; + } + + protected override IEnumerable PerformFetch(Sql sql) + { + return Database.Fetch(new DictionaryLanguageTextRelator().Map, sql); + } + + protected override Sql GetBaseQuery(bool isCount) + { + return _dictionaryRepository.GetBaseQuery(isCount); + } + + protected override string GetBaseWhereClause() + { + return "cmsDictionary." + _dictionaryRepository._syntaxProvider.GetQuotedColumnName("key") + " = @Id"; + } + + protected override IDictionaryItem ConvertToEntity(DictionaryDto dto) + { + return _dictionaryRepository.ConvertFromDto(dto); + } + + protected override object GetBaseWhereClauseArguments(string id) + { + return new { Id = id }; + } + + protected override string GetWhereInClauseForGetAll() + { + return "cmsDictionary." + _dictionaryRepository._syntaxProvider.GetQuotedColumnName("key") + " in (@ids)"; + } + } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDictionaryRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDictionaryRepository.cs index b74dd08477..3a0328294a 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDictionaryRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDictionaryRepository.cs @@ -1,9 +1,11 @@ -using Umbraco.Core.Models; +using System; +using Umbraco.Core.Models; namespace Umbraco.Core.Persistence.Repositories { public interface IDictionaryRepository : IRepositoryQueryable { - + IDictionaryItem Get(Guid uniqueId); + IDictionaryItem Get(string key); } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/ILanguageRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/ILanguageRepository.cs index 01af81f1b7..f927cb433a 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/ILanguageRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/ILanguageRepository.cs @@ -4,6 +4,7 @@ namespace Umbraco.Core.Persistence.Repositories { public interface ILanguageRepository : IRepositoryQueryable { - + ILanguage GetByCultureName(string cultureName); + ILanguage GetByIsoCode(string isoCode); } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs b/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs index e281300c30..5da738d4e7 100644 --- a/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs @@ -17,7 +17,7 @@ namespace Umbraco.Core.Persistence.Repositories /// internal class LanguageRepository : PetaPocoRepositoryBase, ILanguageRepository { - public LanguageRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + public LanguageRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } @@ -33,8 +33,7 @@ namespace Umbraco.Core.Persistence.Repositories if (languageDto == null) return null; - var factory = new LanguageFactory(); - var entity = factory.BuildEntity(languageDto); + var entity = ConvertFromDto(languageDto); //on initial construction we don't want to have dirty properties tracked // http://issues.umbraco.org/issue/U4-1946 @@ -43,41 +42,23 @@ namespace Umbraco.Core.Persistence.Repositories return entity; } - //TODO: Fix this up so there is no N+1 - protected override IEnumerable PerformGetAll(params int[] ids) { + var sql = GetBaseQuery(false).Where("umbracoLanguage.id > 0"); if (ids.Any()) { - foreach (var id in ids) - { - yield return Get(id); - } + sql.Where("umbracoLanguage.id in (@ids)", new { ids = ids }); } - else - { - var dtos = Database.Fetch("WHERE id > 0"); - foreach (var dto in dtos) - { - yield return Get(dto.Id); - } - } - } - //TODO: Fix this up so there is no N+1 + return Database.Fetch(sql).Select(ConvertFromDto); + } protected override IEnumerable PerformGetByQuery(IQuery query) { var sqlClause = GetBaseQuery(false); var translator = new SqlTranslator(sqlClause, query); var sql = translator.Translate(); - - var dtos = Database.Fetch(sql); - - foreach (var dto in dtos) - { - yield return Get(dto.Id); - } + return Database.Fetch(sql).Select(ConvertFromDto); } #endregion @@ -99,7 +80,7 @@ namespace Umbraco.Core.Persistence.Repositories protected override IEnumerable GetDeleteClauses() { - + var list = new List { //NOTE: There is no constraint between the Language and cmsDictionary/cmsLanguageText tables (?) @@ -142,8 +123,117 @@ namespace Umbraco.Core.Persistence.Repositories Database.Update(dto); entity.ResetDirtyProperties(); + + //Clear the cache entries that exist by key/iso + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.IsoCode)); + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.CultureName)); + } + + protected override void PersistDeletedItem(ILanguage entity) + { + base.PersistDeletedItem(entity); + + //Clear the cache entries that exist by key/iso + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.IsoCode)); + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.CultureName)); } #endregion + + protected ILanguage ConvertFromDto(LanguageDto dto) + { + var factory = new LanguageFactory(); + var entity = factory.BuildEntity(dto); + return entity; + } + + public ILanguage GetByCultureName(string cultureName) + { + var cultureNameRepo = new LanguageByCultureNameRepository(this, UnitOfWork, RepositoryCache, Logger); + return cultureNameRepo.Get(cultureName); + } + + public ILanguage GetByIsoCode(string isoCode) + { + var isoRepo = new LanguageByIsoCodeRepository(this, UnitOfWork, RepositoryCache, Logger); + return isoRepo.Get(isoCode); + } + + /// + /// Inner repository for looking up languages by ISO code, this deals with caching by a string key + /// + private class LanguageByIsoCodeRepository : SimpleGetRepository + { + private readonly LanguageRepository _languageRepository; + + public LanguageByIsoCodeRepository(LanguageRepository languageRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) + : base(work, cache, logger) + { + _languageRepository = languageRepository; + } + + protected override Sql GetBaseQuery(bool isCount) + { + return _languageRepository.GetBaseQuery(isCount); + } + + protected override string GetBaseWhereClause() + { + return "umbracoLanguage.languageISOCode = @Id"; + } + + protected override ILanguage ConvertToEntity(LanguageDto dto) + { + var factory = new LanguageFactory(); + return factory.BuildEntity(dto); + } + + protected override object GetBaseWhereClauseArguments(string id) + { + return new {Id = id}; + } + + protected override string GetWhereInClauseForGetAll() + { + return "umbracoLanguage.languageISOCode in (@ids)"; + } + } + + private class LanguageByCultureNameRepository : SimpleGetRepository + { + private readonly LanguageRepository _languageRepository; + + public LanguageByCultureNameRepository(LanguageRepository languageRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) + : base(work, cache, logger) + { + _languageRepository = languageRepository; + } + + protected override Sql GetBaseQuery(bool isCount) + { + return _languageRepository.GetBaseQuery(isCount); + } + + protected override string GetBaseWhereClause() + { + return "umbracoLanguage.languageCultureName = @Id"; + } + + protected override ILanguage ConvertToEntity(LanguageDto dto) + { + var factory = new LanguageFactory(); + return factory.BuildEntity(dto); + } + + protected override object GetBaseWhereClauseArguments(string id) + { + return new {Id = id}; + } + + protected override string GetWhereInClauseForGetAll() + { + return "umbracoLanguage.languageCultureName in (@ids)"; + } + } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs index e112e4df6b..7d02a31d4c 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs @@ -16,8 +16,8 @@ namespace Umbraco.Core.Persistence.Repositories { internal class MacroRepository : PetaPocoRepositoryBase, IMacroRepository { - - public MacroRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + + public MacroRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs index 76ab50962b..dad616f837 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs @@ -31,15 +31,15 @@ namespace Umbraco.Core.Persistence.Repositories private readonly ContentXmlRepository _contentXmlRepository; private readonly ContentPreviewRepository _contentPreviewRepository; - public MediaRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository) + public MediaRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository) : base(work, cache, logger) { if (mediaTypeRepository == null) throw new ArgumentNullException("mediaTypeRepository"); if (tagRepository == null) throw new ArgumentNullException("tagRepository"); _mediaTypeRepository = mediaTypeRepository; _tagRepository = tagRepository; - _contentXmlRepository = new ContentXmlRepository(work, NullCacheProvider.Current, logger); - _contentPreviewRepository = new ContentPreviewRepository(work, NullCacheProvider.Current, logger); + _contentXmlRepository = new ContentXmlRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger); + _contentPreviewRepository = new ContentPreviewRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger); EnsureUniqueNaming = true; } diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs index 98682cd85b..18f7285e8b 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs @@ -17,8 +17,8 @@ namespace Umbraco.Core.Persistence.Repositories /// internal class MediaTypeRepository : ContentTypeBaseRepository, IMediaTypeRepository { - - public MediaTypeRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + + public MediaTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs index 171e697545..3719dd0ee1 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs @@ -21,8 +21,8 @@ namespace Umbraco.Core.Persistence.Repositories internal class MemberGroupRepository : PetaPocoRepositoryBase, IMemberGroupRepository { private readonly CacheHelper _cacheHelper; - - public MemberGroupRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger, CacheHelper cacheHelper) + + public MemberGroupRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, CacheHelper cacheHelper) : base(work, cache, logger) { if (cacheHelper == null) throw new ArgumentNullException("cacheHelper"); diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs index 3c576e49bd..c5f05d4d96 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs @@ -33,7 +33,7 @@ namespace Umbraco.Core.Persistence.Repositories private readonly ContentXmlRepository _contentXmlRepository; private readonly ContentPreviewRepository _contentPreviewRepository; - public MemberRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository) + public MemberRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository) : base(work, cache, logger) { if (memberTypeRepository == null) throw new ArgumentNullException("memberTypeRepository"); @@ -41,8 +41,8 @@ namespace Umbraco.Core.Persistence.Repositories _memberTypeRepository = memberTypeRepository; _tagRepository = tagRepository; _memberGroupRepository = memberGroupRepository; - _contentXmlRepository = new ContentXmlRepository(work, NullCacheProvider.Current, logger); - _contentPreviewRepository = new ContentPreviewRepository(work, NullCacheProvider.Current, logger); + _contentXmlRepository = new ContentXmlRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger); + _contentPreviewRepository = new ContentPreviewRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger); } #region Overrides of RepositoryBase diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs index 4c8a915fac..864fe936cd 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs @@ -20,7 +20,7 @@ namespace Umbraco.Core.Persistence.Repositories internal class MemberTypeRepository : ContentTypeBaseRepository, IMemberTypeRepository { - public MemberTypeRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + public MemberTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/PetaPocoRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/PetaPocoRepositoryBase.cs index ccf731f040..9ed04d9020 100644 --- a/src/Umbraco.Core/Persistence/Repositories/PetaPocoRepositoryBase.cs +++ b/src/Umbraco.Core/Persistence/Repositories/PetaPocoRepositoryBase.cs @@ -17,7 +17,7 @@ namespace Umbraco.Core.Persistence.Repositories where TEntity : class, IAggregateRoot { - protected PetaPocoRepositoryBase(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + protected PetaPocoRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs index 859c3bbfb9..420b194453 100644 --- a/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs @@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories internal abstract class RecycleBinRepository : VersionableRepositoryBase, IRecycleBinRepository where TEntity : class, IUmbracoEntity { - protected RecycleBinRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + protected RecycleBinRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs index b0f5445f3a..7ee663ee77 100644 --- a/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs @@ -19,7 +19,7 @@ namespace Umbraco.Core.Persistence.Repositories { private readonly IRelationTypeRepository _relationTypeRepository; - public RelationRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger, IRelationTypeRepository relationTypeRepository) + public RelationRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IRelationTypeRepository relationTypeRepository) : base(work, cache, logger) { _relationTypeRepository = relationTypeRepository; @@ -50,6 +50,8 @@ namespace Umbraco.Core.Persistence.Repositories return entity; } + //TODO: Fix N+1 ! + protected override IEnumerable PerformGetAll(params int[] ids) { if (ids.Any()) diff --git a/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs index 977ca779c6..65a07d767f 100644 --- a/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs @@ -18,7 +18,7 @@ namespace Umbraco.Core.Persistence.Repositories internal class RelationTypeRepository : PetaPocoRepositoryBase, IRelationTypeRepository { - public RelationTypeRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + public RelationTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/RepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/RepositoryBase.cs index 8a74fd0204..edb8b27e86 100644 --- a/src/Umbraco.Core/Persistence/Repositories/RepositoryBase.cs +++ b/src/Umbraco.Core/Persistence/Repositories/RepositoryBase.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Umbraco.Core.Cache; using Umbraco.Core.Logging; using Umbraco.Core.Models.EntityBase; using Umbraco.Core.Persistence.Caching; @@ -9,25 +10,17 @@ using Umbraco.Core.Persistence.UnitOfWork; namespace Umbraco.Core.Persistence.Repositories { - - /// - /// Represent an abstract Repository, which is the base of the Repository implementations - /// - /// Type of entity for which the repository is used - /// Type of the Id used for this entity - internal abstract class RepositoryBase : DisposableObject, IRepositoryQueryable, IUnitOfWorkRepository - where TEntity : class, IAggregateRoot + internal abstract class RepositoryBase : DisposableObject { - protected ILogger Logger { get; private set; } - private readonly IUnitOfWork _work; - private readonly IRepositoryCacheProvider _cache; + private readonly CacheHelper _cache; - protected RepositoryBase(IUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + protected RepositoryBase(IUnitOfWork work, CacheHelper cache, ILogger logger) { - Logger = logger; if (work == null) throw new ArgumentNullException("work"); if (cache == null) throw new ArgumentNullException("cache"); + if (logger == null) throw new ArgumentNullException("logger"); + Logger = logger; _work = work; _cache = cache; } @@ -48,6 +41,37 @@ namespace Umbraco.Core.Persistence.Repositories get { return (Guid)_work.Key; } } + protected CacheHelper RepositoryCache + { + get { return _cache; } + } + + public static string GetCacheIdKey(object id) + { + return string.Format("{0}{1}", GetCacheTypeKey(), id); + } + + public static string GetCacheTypeKey() + { + return string.Format("uRepo_{0}_", typeof(T).Name); + } + + protected ILogger Logger { get; private set; } + } + + /// + /// Represent an abstract Repository, which is the base of the Repository implementations + /// + /// Type of entity for which the repository is used + /// Type of the Id used for this entity + internal abstract class RepositoryBase : RepositoryBase, IRepositoryQueryable, IUnitOfWorkRepository + where TEntity : class, IAggregateRoot + { + protected RepositoryBase(IUnitOfWork work, CacheHelper cache, ILogger logger) + : base(work, cache, logger) + { + } + #region IRepository Members /// @@ -59,11 +83,11 @@ namespace Umbraco.Core.Persistence.Repositories { if (entity.HasIdentity == false) { - _work.RegisterAdded(entity, this); + UnitOfWork.RegisterAdded(entity, this); } else { - _work.RegisterChanged(entity, this); + UnitOfWork.RegisterChanged(entity, this); } } @@ -73,9 +97,9 @@ namespace Umbraco.Core.Persistence.Repositories /// public virtual void Delete(TEntity entity) { - if (_work != null) + if (UnitOfWork != null) { - _work.RegisterRemoved(entity, this); + UnitOfWork.RegisterRemoved(entity, this); } } @@ -87,42 +111,33 @@ namespace Umbraco.Core.Persistence.Repositories /// public TEntity Get(TId id) { - var fromCache = TryGetFromCache(id); - if (fromCache.Success) - { - return fromCache.Result; - } - - var entity = PerformGet(id); - if (entity != null) - { - _cache.Save(typeof(TEntity), entity); - } - - if (entity != null) - { - //on initial construction we don't want to have dirty properties tracked - // http://issues.umbraco.org/issue/U4-1946 - var asEntity = entity as TracksChangesEntityBase; - if (asEntity != null) + return RepositoryCache.RuntimeCache.GetCacheItem( + GetCacheIdKey(id), () => { - asEntity.ResetDirtyProperties(false); - } - } - - return entity; + var entity = PerformGet(id); + if (entity == null) return null; + //on initial construction we don't want to have dirty properties tracked + // http://issues.umbraco.org/issue/U4-1946 + var asEntity = entity as TracksChangesEntityBase; + if (asEntity != null) + { + asEntity.ResetDirtyProperties(false); + } + return entity; + }); } - protected Attempt TryGetFromCache(TId id) - { - Guid key = id is int ? ConvertIdToGuid(id) : ConvertStringIdToGuid(id.ToString()); - var rEntity = _cache.GetById(typeof(TEntity), key); - if (rEntity != null) - { - return Attempt.Succeed((TEntity)rEntity); - } - return Attempt.Fail(); - } + + //protected Attempt TryGetFromCache(TId id) + //{ + // Guid key = id is int ? ConvertIdToGuid(id) : ConvertStringIdToGuid(id.ToString()); + // var rEntity = RepositoryCache.GetById(typeof(TEntity), key); + // if (rEntity != null) + // { + // return Attempt.Succeed((TEntity)rEntity); + // } + // return Attempt.Fail(); + //} protected abstract IEnumerable PerformGetAll(params TId[] ids); /// @@ -146,16 +161,20 @@ namespace Umbraco.Core.Persistence.Repositories if (ids.Any()) { - var entities = _cache.GetByIds( - typeof(TEntity), ids.Select(id => id is int ? ConvertIdToGuid(id) : ConvertStringIdToGuid(id.ToString())).ToList()) - .ToArray(); + var entities = ids.Select(x => RepositoryCache.RuntimeCache.GetCacheItem(GetCacheIdKey(x))).ToArray(); + + //var entities = RepositoryCache.GetByIds( + // typeof(TEntity), ids.Select(id => id is int ? ConvertIdToGuid(id) : ConvertStringIdToGuid(id.ToString())).ToList()) + // .ToArray(); if (ids.Count().Equals(entities.Count()) && entities.Any(x => x == null) == false) return entities.Select(x => (TEntity)x); } else { - var allEntities = _cache.GetAllByType(typeof(TEntity)).ToArray(); + var allEntities = RepositoryCache.RuntimeCache.GetCacheItemsByKeySearch(GetCacheTypeKey()).ToArray(); + + //var allEntities = RepositoryCache.GetAllByType(typeof(TEntity)).ToArray(); if (allEntities.Any()) { @@ -183,7 +202,9 @@ namespace Umbraco.Core.Persistence.Repositories { if (entity != null) { - _cache.Save(typeof(TEntity), entity); + var localCopy = entity; + RepositoryCache.RuntimeCache.InsertCacheItem(GetCacheIdKey(entity.Id), () => localCopy); + //RepositoryCache.Save(typeof(TEntity), entity); } } @@ -211,11 +232,16 @@ namespace Umbraco.Core.Persistence.Repositories /// public bool Exists(TId id) { - var fromCache = TryGetFromCache(id); - if (fromCache.Success) + var fromCache = RepositoryCache.RuntimeCache.GetCacheItem(GetCacheIdKey(id)); + if (fromCache != null) { return true; } + //var fromCache = TryGetFromCache(id); + //if (fromCache.Success) + //{ + // return true; + //} return PerformExists(id); } @@ -243,13 +269,15 @@ namespace Umbraco.Core.Persistence.Repositories try { PersistNewItem((TEntity)entity); - _cache.Save(typeof(TEntity), entity); + RepositoryCache.RuntimeCache.InsertCacheItem(GetCacheIdKey(entity.Id), () => entity); + //RepositoryCache.Save(typeof(TEntity), entity); } catch (Exception) { //if an exception is thrown we need to remove the entry from cache, this is ONLY a work around because of the way // that we cache entities: http://issues.umbraco.org/issue/U4-4259 - _cache.Delete(typeof(TEntity), entity); + //RepositoryCache.Delete(typeof(TEntity), entity); + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.Id)); throw; } @@ -264,13 +292,15 @@ namespace Umbraco.Core.Persistence.Repositories try { PersistUpdatedItem((TEntity)entity); - _cache.Save(typeof(TEntity), entity); + RepositoryCache.RuntimeCache.InsertCacheItem(GetCacheIdKey(entity.Id), () => entity); + //RepositoryCache.Save(typeof(TEntity), entity); } catch (Exception) { //if an exception is thrown we need to remove the entry from cache, this is ONLY a work around because of the way // that we cache entities: http://issues.umbraco.org/issue/U4-4259 - _cache.Delete(typeof(TEntity), entity); + //RepositoryCache.Delete(typeof(TEntity), entity); + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.Id)); throw; } @@ -283,7 +313,8 @@ namespace Umbraco.Core.Persistence.Repositories public virtual void PersistDeletedItem(IEntity entity) { PersistDeletedItem((TEntity)entity); - _cache.Delete(typeof(TEntity), entity); + //RepositoryCache.Delete(typeof(TEntity), entity); + RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey(entity.Id)); } #endregion @@ -296,29 +327,29 @@ namespace Umbraco.Core.Persistence.Repositories #endregion - /// - /// Internal method that handles the convertion of an object Id - /// to an Integer and then a Guid Id. - /// - /// In the future it should be possible to change this method - /// so it converts from object to guid if/when we decide to go from - /// int to guid based ids. - /// - /// - protected virtual Guid ConvertIdToGuid(TId id) - { - int i = 0; - if (int.TryParse(id.ToString(), out i)) - { - return i.ToGuid(); - } - return ConvertStringIdToGuid(id.ToString()); - } + ///// + ///// Internal method that handles the convertion of an object Id + ///// to an Integer and then a Guid Id. + ///// + ///// In the future it should be possible to change this method + ///// so it converts from object to guid if/when we decide to go from + ///// int to guid based ids. + ///// + ///// + //protected virtual Guid ConvertIdToGuid(TId id) + //{ + // int i = 0; + // if (int.TryParse(id.ToString(), out i)) + // { + // return i.ToGuid(); + // } + // return ConvertStringIdToGuid(id.ToString()); + //} - protected virtual Guid ConvertStringIdToGuid(string id) - { - return id.EncodeAsGuid(); - } + //protected virtual Guid ConvertStringIdToGuid(string id) + //{ + // return id.EncodeAsGuid(); + //} /// /// Dispose disposable properties diff --git a/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs index d7b4910633..6eafb5ef5e 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs @@ -14,7 +14,7 @@ namespace Umbraco.Core.Persistence.Repositories { internal class ServerRegistrationRepository : PetaPocoRepositoryBase { - public ServerRegistrationRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + public ServerRegistrationRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs b/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs new file mode 100644 index 0000000000..af0db54955 --- /dev/null +++ b/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs @@ -0,0 +1,99 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Umbraco.Core.Logging; +using Umbraco.Core.Models.EntityBase; +using Umbraco.Core.Persistence.Caching; +using Umbraco.Core.Persistence.Querying; +using Umbraco.Core.Persistence.UnitOfWork; + +namespace Umbraco.Core.Persistence.Repositories +{ + /// + /// Simple abstract ReadOnly repository used to simply have PerformGet and PeformGetAll with an underlying cache + /// + internal abstract class SimpleGetRepository : PetaPocoRepositoryBase + where TEntity : class, IAggregateRoot + where TDto: class + { + + protected SimpleGetRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) + : base(work, cache, logger) + { + } + + protected abstract TEntity ConvertToEntity(TDto dto); + protected abstract object GetBaseWhereClauseArguments(TId id); + protected abstract string GetWhereInClauseForGetAll(); + + protected virtual IEnumerable PerformFetch(Sql sql) + { + return Database.Fetch(sql); + } + + protected override TEntity PerformGet(TId id) + { + var sql = GetBaseQuery(false); + sql.Where(GetBaseWhereClause(), GetBaseWhereClauseArguments(id)); + + var dto = PerformFetch(sql).FirstOrDefault(); + if (dto == null) + return null; + + var entity = ConvertToEntity(dto); + + var dirtyEntity = entity as Entity; + if (dirtyEntity != null) + { + //on initial construction we don't want to have dirty properties tracked + // http://issues.umbraco.org/issue/U4-1946 + dirtyEntity.ResetDirtyProperties(false); + } + + return entity; + } + + protected override IEnumerable PerformGetAll(params TId[] ids) + { + var sql = new Sql().From(); + + if (ids.Any()) + { + sql.Where(GetWhereInClauseForGetAll(), new { ids = ids }); + } + + return Database.Fetch(sql).Select(ConvertToEntity); + } + + protected override sealed IEnumerable PerformGetByQuery(IQuery query) + { + var sqlClause = GetBaseQuery(false); + var translator = new SqlTranslator(sqlClause, query); + var sql = translator.Translate(); + return Database.Fetch(sql).Select(ConvertToEntity); + } + + #region Not implemented and not required + + protected override sealed IEnumerable GetDeleteClauses() + { + throw new NotImplementedException(); + } + + protected override sealed Guid NodeObjectTypeId + { + get { throw new NotImplementedException(); } + } + + protected override sealed void PersistNewItem(TEntity entity) + { + throw new NotImplementedException(); + } + + protected override sealed void PersistUpdatedItem(TEntity entity) + { + throw new NotImplementedException(); + } + #endregion + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs index ac8ed2dbd0..53b2971fea 100644 --- a/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs @@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories { internal class TagRepository : PetaPocoRepositoryBase, ITagRepository { - internal TagRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + internal TagRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs index 5c3f39e228..df7b0dc1e7 100644 --- a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs @@ -33,7 +33,7 @@ namespace Umbraco.Core.Persistence.Repositories private readonly ViewHelper _viewHelper; private readonly MasterPageHelper _masterPageHelper; - internal TemplateRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger, IFileSystem masterpageFileSystem, IFileSystem viewFileSystem, ITemplatesSection templateConfig) + internal TemplateRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IFileSystem masterpageFileSystem, IFileSystem viewFileSystem, ITemplatesSection templateConfig) : base(work, cache, logger) { _masterpagesFileSystem = masterpageFileSystem; diff --git a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs index 5c0107764e..6d4bb7f2ba 100644 --- a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs @@ -26,7 +26,7 @@ namespace Umbraco.Core.Persistence.Repositories private readonly IUserTypeRepository _userTypeRepository; private readonly CacheHelper _cacheHelper; - public UserRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger, IUserTypeRepository userTypeRepository, CacheHelper cacheHelper) + public UserRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IUserTypeRepository userTypeRepository, CacheHelper cacheHelper) : base(work, cache, logger) { _userTypeRepository = userTypeRepository; diff --git a/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs index 189eeb48ae..1b9c2469b1 100644 --- a/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs @@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories /// internal class UserTypeRepository : PetaPocoRepositoryBase, IUserTypeRepository { - public UserTypeRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + public UserTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs index 4c56b523fa..c4b21dbd9d 100644 --- a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs +++ b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs @@ -22,8 +22,8 @@ namespace Umbraco.Core.Persistence.Repositories internal abstract class VersionableRepositoryBase : PetaPocoRepositoryBase where TEntity : class, IAggregateRoot { - - protected VersionableRepositoryBase(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger) + + protected VersionableRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger) : base(work, cache, logger) { } diff --git a/src/Umbraco.Core/Persistence/RepositoryFactory.cs b/src/Umbraco.Core/Persistence/RepositoryFactory.cs index 8640d4461a..bf1e1395ad 100644 --- a/src/Umbraco.Core/Persistence/RepositoryFactory.cs +++ b/src/Umbraco.Core/Persistence/RepositoryFactory.cs @@ -5,6 +5,7 @@ using Umbraco.Core.IO; using Umbraco.Core.Logging; using Umbraco.Core.Persistence.Caching; using Umbraco.Core.Persistence.Repositories; +using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Persistence.UnitOfWork; namespace Umbraco.Core.Persistence @@ -14,62 +15,50 @@ namespace Umbraco.Core.Persistence /// public class RepositoryFactory { - private readonly bool _disableAllCache; private readonly ILogger _logger; + private readonly ISqlSyntaxProvider _sqlSyntax; private readonly CacheHelper _cacheHelper; private readonly IUmbracoSettingsSection _settings; #region Ctors - public RepositoryFactory(CacheHelper cacheHelper, ILogger logger, IUmbracoSettingsSection settings) + public RepositoryFactory(CacheHelper cacheHelper, ILogger logger, ISqlSyntaxProvider sqlSyntax, IUmbracoSettingsSection settings) { if (cacheHelper == null) throw new ArgumentNullException("cacheHelper"); if (logger == null) throw new ArgumentNullException("logger"); + if (sqlSyntax == null) throw new ArgumentNullException("sqlSyntax"); if (settings == null) throw new ArgumentNullException("settings"); - _disableAllCache = false; + _cacheHelper = cacheHelper; _logger = logger; + _sqlSyntax = sqlSyntax; _settings = settings; } - public RepositoryFactory(bool disableAllCache, ILogger logger, IUmbracoSettingsSection settings) - { - if (logger == null) throw new ArgumentNullException("logger"); - if (settings == null) throw new ArgumentNullException("settings"); - _disableAllCache = disableAllCache; - _logger = logger; - _settings = settings; - _cacheHelper = _disableAllCache ? CacheHelper.CreateDisabledCacheHelper() : ApplicationContext.Current.ApplicationCache; - } - [Obsolete("Use the ctor specifying all dependencies instead")] public RepositoryFactory() - : this(false, LoggerResolver.Current.Logger, UmbracoConfig.For.UmbracoSettings()) + : this(ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings()) { } - [Obsolete("Use the ctor specifying an ILogger instead")] + [Obsolete("Use the ctor specifying all dependencies instead")] public RepositoryFactory(CacheHelper cacheHelper) - : this(false, LoggerResolver.Current.Logger, UmbracoConfig.For.UmbracoSettings()) + : this(cacheHelper, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings()) { - if (cacheHelper == null) throw new ArgumentNullException("cacheHelper"); - _disableAllCache = false; - _cacheHelper = cacheHelper; } - [Obsolete("Use the ctor specifying an ILogger instead")] + [Obsolete("Use the ctor specifying all dependencies instead, NOTE: disableAllCache has zero effect")] public RepositoryFactory(bool disableAllCache, CacheHelper cacheHelper) - : this(disableAllCache, LoggerResolver.Current.Logger, UmbracoConfig.For.UmbracoSettings()) + : this(cacheHelper, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings()) { if (cacheHelper == null) throw new ArgumentNullException("cacheHelper"); _cacheHelper = cacheHelper; } - [Obsolete("Use the ctor specifying an ILogger instead")] + [Obsolete("Use the ctor specifying all dependencies instead")] public RepositoryFactory(bool disableAllCache) - : this(disableAllCache, LoggerResolver.Current.Logger, UmbracoConfig.For.UmbracoSettings()) + : this(disableAllCache ? CacheHelper.CreateDisabledCacheHelper() : ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings()) { - } @@ -79,14 +68,14 @@ namespace Umbraco.Core.Persistence { return new TagRepository( uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, _logger); + _cacheHelper, _logger); } public virtual IContentRepository CreateContentRepository(IDatabaseUnitOfWork uow) { return new ContentRepository( - uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + uow, + _cacheHelper, _logger, CreateContentTypeRepository(uow), CreateTemplateRepository(uow), @@ -98,7 +87,7 @@ namespace Umbraco.Core.Persistence { return new ContentTypeRepository( uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _logger, CreateTemplateRepository(uow)); } @@ -107,7 +96,7 @@ namespace Umbraco.Core.Persistence { return new DataTypeDefinitionRepository( uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _cacheHelper, _logger, CreateContentTypeRepository(uow)); @@ -117,8 +106,9 @@ namespace Umbraco.Core.Persistence { return new DictionaryRepository( uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _logger, + _sqlSyntax, CreateLanguageRepository(uow)); } @@ -126,7 +116,7 @@ namespace Umbraco.Core.Persistence { return new LanguageRepository( uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _logger); } @@ -134,7 +124,7 @@ namespace Umbraco.Core.Persistence { return new MediaRepository( uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _logger, CreateMediaTypeRepository(uow), CreateTagRepository(uow)) { EnsureUniqueNaming = _settings.Content.EnsureUniqueNaming }; @@ -144,7 +134,7 @@ namespace Umbraco.Core.Persistence { return new MediaTypeRepository( uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _logger); } @@ -152,7 +142,7 @@ namespace Umbraco.Core.Persistence { return new RelationRepository( uow, - NullCacheProvider.Current, + CacheHelper.CreateDisabledCacheHelper(), //never cache _logger, CreateRelationTypeRepository(uow)); } @@ -161,7 +151,7 @@ namespace Umbraco.Core.Persistence { return new RelationTypeRepository( uow, - NullCacheProvider.Current, + CacheHelper.CreateDisabledCacheHelper(), //never cache _logger); } @@ -188,7 +178,7 @@ namespace Umbraco.Core.Persistence public virtual ITemplateRepository CreateTemplateRepository(IDatabaseUnitOfWork uow) { return new TemplateRepository(uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _logger, new PhysicalFileSystem(SystemDirectories.Masterpages), new PhysicalFileSystem(SystemDirectories.MvcViews), @@ -199,7 +189,7 @@ namespace Umbraco.Core.Persistence { return new ServerRegistrationRepository( uow, - NullCacheProvider.Current, + CacheHelper.CreateDisabledCacheHelper(), //never cache _logger); } @@ -208,7 +198,7 @@ namespace Umbraco.Core.Persistence return new UserTypeRepository( uow, //There's not many user types but we query on users all the time so the result needs to be cached - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _logger); } @@ -217,7 +207,7 @@ namespace Umbraco.Core.Persistence return new UserRepository( uow, //Need to cache users - we look up user information more than anything in the back office! - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _logger, CreateUserTypeRepository(uow), _cacheHelper); @@ -225,8 +215,8 @@ namespace Umbraco.Core.Persistence internal virtual IMacroRepository CreateMacroRepository(IDatabaseUnitOfWork uow) { - return new MacroRepository(uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + return new MacroRepository(uow, + _cacheHelper, _logger); } @@ -234,7 +224,7 @@ namespace Umbraco.Core.Persistence { return new MemberRepository( uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + _cacheHelper, _logger, CreateMemberTypeRepository(uow), CreateMemberGroupRepository(uow), @@ -243,15 +233,15 @@ namespace Umbraco.Core.Persistence public virtual IMemberTypeRepository CreateMemberTypeRepository(IDatabaseUnitOfWork uow) { - return new MemberTypeRepository(uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + return new MemberTypeRepository(uow, + _cacheHelper, _logger); } public virtual IMemberGroupRepository CreateMemberGroupRepository(IDatabaseUnitOfWork uow) { - return new MemberGroupRepository(uow, - _disableAllCache ? (IRepositoryCacheProvider)NullCacheProvider.Current : RuntimeCacheProvider.Current, + return new MemberGroupRepository(uow, + _cacheHelper, _logger, _cacheHelper); } diff --git a/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProvidersResolver.cs b/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProvidersResolver.cs index 8db914801d..1ba9edca73 100644 --- a/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProvidersResolver.cs +++ b/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProvidersResolver.cs @@ -8,6 +8,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax /// /// A resolver to return all ISqlSyntaxProvider objects /// + [Obsolete("This should really not be used, instead ISqlSyntaxProvider should be ctor injected into any service that needs it")] internal sealed class SqlSyntaxProvidersResolver : ManyObjectsResolverBase { /// diff --git a/src/Umbraco.Core/Services/ContentService.cs b/src/Umbraco.Core/Services/ContentService.cs index b232a73a6e..eb22e44094 100644 --- a/src/Umbraco.Core/Services/ContentService.cs +++ b/src/Umbraco.Core/Services/ContentService.cs @@ -41,7 +41,7 @@ namespace Umbraco.Core.Services [Obsolete("Use the constructors that specify all dependencies instead")] public ContentService() - : this(LoggerResolver.Current.Logger, new RepositoryFactory(false, LoggerResolver.Current.Logger, UmbracoConfig.For.UmbracoSettings())) + : this(LoggerResolver.Current.Logger, new RepositoryFactory(ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings())) { } [Obsolete("Use the constructors that specify all dependencies instead")] @@ -51,7 +51,7 @@ namespace Umbraco.Core.Services [Obsolete("Use the constructors that specify all dependencies instead")] public ContentService(ILogger logger, IDatabaseUnitOfWorkProvider provider) - : this(logger, provider, new RepositoryFactory(false, LoggerResolver.Current.Logger, UmbracoConfig.For.UmbracoSettings()), new PublishingStrategy()) + : this(logger, provider, new RepositoryFactory(ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings()), new PublishingStrategy()) { } [Obsolete("Use the constructors that specify all dependencies instead")] @@ -1330,9 +1330,9 @@ namespace Umbraco.Core.Services Audit.Add(AuditTypes.Copy, "Copy Content performed by user", content.WriterId, content.Id); - //TODO: Don't think we need this here because cache should be cleared by the event listeners - // and the correct ICacheRefreshers!? - RuntimeCacheProvider.Current.Clear(); + ////TODO: Don't think we need this here because cache should be cleared by the event listeners + //// and the correct ICacheRefreshers!? + //RuntimeCacheProvider.Current.Clear(); return copy; } diff --git a/src/Umbraco.Core/Services/LocalizationService.cs b/src/Umbraco.Core/Services/LocalizationService.cs index 65229dcb74..7fb7ae379c 100644 --- a/src/Umbraco.Core/Services/LocalizationService.cs +++ b/src/Umbraco.Core/Services/LocalizationService.cs @@ -8,6 +8,7 @@ using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Persistence; using Umbraco.Core.Persistence.Querying; +using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Persistence.UnitOfWork; namespace Umbraco.Core.Services @@ -23,7 +24,7 @@ namespace Umbraco.Core.Services [Obsolete("Use the constructors that specify all dependencies instead")] public LocalizationService() - : this(new RepositoryFactory(false, LoggerResolver.Current.Logger, UmbracoConfig.For.UmbracoSettings())) + : this(new RepositoryFactory(ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings())) {} [Obsolete("Use the constructors that specify all dependencies instead")] @@ -34,7 +35,7 @@ namespace Umbraco.Core.Services [Obsolete("Use the constructors that specify all dependencies instead")] public LocalizationService(IDatabaseUnitOfWorkProvider provider) - : this(provider, new RepositoryFactory(false, LoggerResolver.Current.Logger, UmbracoConfig.For.UmbracoSettings())) + : this(provider, new RepositoryFactory(ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings())) { } @@ -141,10 +142,11 @@ namespace Umbraco.Core.Services { using (var repository = _repositoryFactory.CreateDictionaryRepository(_uowProvider.GetUnitOfWork())) { - var query = Query.Builder.Where(x => x.Key == id); - var items = repository.GetByQuery(query); + return repository.Get(id); + //var query = Query.Builder.Where(x => x.Key == id); + //var items = repository.GetByQuery(query); - return items.FirstOrDefault(); + //return items.FirstOrDefault(); } } @@ -157,10 +159,11 @@ namespace Umbraco.Core.Services { using (var repository = _repositoryFactory.CreateDictionaryRepository(_uowProvider.GetUnitOfWork())) { - var query = Query.Builder.Where(x => x.ItemKey == key); - var items = repository.GetByQuery(query); + return repository.Get(key); + //var query = Query.Builder.Where(x => x.ItemKey == key); + //var items = repository.GetByQuery(query); - return items.FirstOrDefault(); + //return items.FirstOrDefault(); } } @@ -204,10 +207,11 @@ namespace Umbraco.Core.Services { using (var repository = _repositoryFactory.CreateDictionaryRepository(_uowProvider.GetUnitOfWork())) { - var query = Query.Builder.Where(x => x.ItemKey == key); - var items = repository.GetByQuery(query); + return repository.Get(key) != null; + //var query = Query.Builder.Where(x => x.ItemKey == key); + //var items = repository.GetByQuery(query); - return items.Any(); + //return items.Any(); } } @@ -279,10 +283,11 @@ namespace Umbraco.Core.Services { using (var repository = _repositoryFactory.CreateLanguageRepository(_uowProvider.GetUnitOfWork())) { - var query = Query.Builder.Where(x => x.CultureName == cultureName); - var items = repository.GetByQuery(query); + return repository.GetByCultureName(cultureName); + //var query = Query.Builder.Where(x => x.CultureName == cultureName); + //var items = repository.GetByQuery(query); - return items.FirstOrDefault(); + //return items.FirstOrDefault(); } } @@ -295,10 +300,11 @@ namespace Umbraco.Core.Services { using (var repository = _repositoryFactory.CreateLanguageRepository(_uowProvider.GetUnitOfWork())) { - var query = Query.Builder.Where(x => x.IsoCode == isoCode); - var items = repository.GetByQuery(query); + return repository.GetByIsoCode(isoCode); + //var query = Query.Builder.Where(x => x.IsoCode == isoCode); + //var items = repository.GetByQuery(query); - return items.FirstOrDefault(); + //return items.FirstOrDefault(); } } diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index 491bff9256..8231605428 100644 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -321,6 +321,7 @@ + diff --git a/src/Umbraco.Tests/Migrations/Upgrades/ValidateV7TagsUpgradeTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/ValidateV7TagsUpgradeTest.cs index d5c63c8946..47a5b9d851 100644 --- a/src/Umbraco.Tests/Migrations/Upgrades/ValidateV7TagsUpgradeTest.cs +++ b/src/Umbraco.Tests/Migrations/Upgrades/ValidateV7TagsUpgradeTest.cs @@ -25,10 +25,10 @@ namespace Umbraco.Tests.Migrations.Upgrades { private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { - var templateRepository = new TemplateRepository(unitOfWork, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); - var tagRepository = new TagRepository(unitOfWork, Mock.Of(), Mock.Of()); - contentTypeRepository = new ContentTypeRepository(unitOfWork, Mock.Of(), Mock.Of(), templateRepository); - var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); + var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); + var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), templateRepository); + var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); return repository; } diff --git a/src/Umbraco.Tests/MockTests.cs b/src/Umbraco.Tests/MockTests.cs index a4ace4c1ed..2a64d5dbbb 100644 --- a/src/Umbraco.Tests/MockTests.cs +++ b/src/Umbraco.Tests/MockTests.cs @@ -8,6 +8,7 @@ using Umbraco.Core; using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.Logging; using Umbraco.Core.Persistence; +using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Persistence.UnitOfWork; using Umbraco.Core.Services; using Moq; @@ -46,12 +47,12 @@ namespace Umbraco.Tests new Mock().Object, new Mock().Object, new Mock().Object, - new RepositoryFactory(true, Mock.Of(), Mock.Of()), + new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of()), new Mock().Object), new Mock().Object, new RelationService( new Mock().Object, - new RepositoryFactory(true, Mock.Of(), Mock.Of()), + new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of()), new Mock().Object), new Mock().Object, new Mock().Object, @@ -94,12 +95,12 @@ namespace Umbraco.Tests new Mock().Object, new Mock().Object, new Mock().Object, - new RepositoryFactory(true, Mock.Of(), Mock.Of()), + new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of()), new Mock().Object), new Mock().Object, new RelationService( new Mock().Object, - new RepositoryFactory(true, Mock.Of(), Mock.Of()), + new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of()), new Mock().Object), new Mock().Object, new Mock().Object, diff --git a/src/Umbraco.Tests/Models/ContentTests.cs b/src/Umbraco.Tests/Models/ContentTests.cs index dfaaae1d27..fb1b1520f0 100644 --- a/src/Umbraco.Tests/Models/ContentTests.cs +++ b/src/Umbraco.Tests/Models/ContentTests.cs @@ -1,11 +1,13 @@ using System; using System.Collections.Generic; +using System.Globalization; using System.IO; using System.Linq; using System.Web; using Moq; using NUnit.Framework; using Umbraco.Core; +using Umbraco.Core.Cache; using Umbraco.Core.Exceptions; using Umbraco.Core.Models; using Umbraco.Core.Models.EntityBase; @@ -220,14 +222,14 @@ namespace Umbraco.Tests.Models ((IUmbracoEntity)content).AdditionalData.Add("test1", 123); ((IUmbracoEntity)content).AdditionalData.Add("test2", "hello"); - var runtimeCache = new RuntimeCacheProvider(); - runtimeCache.Save(typeof(IContent), content); + var runtimeCache = new ObjectCacheRuntimeCacheProvider(); + runtimeCache.InsertCacheItem(content.Id.ToString(CultureInfo.InvariantCulture), () => content); using (DisposableTimer.DebugDuration("STARTING PERF TEST WITH RUNTIME CACHE")) { for (int j = 0; j < 1000; j++) { - var clone = runtimeCache.GetById(typeof(IContent), content.Id.ToGuid()); + var clone = runtimeCache.GetCacheItem(content.Id.ToString(CultureInfo.InvariantCulture)); } } diff --git a/src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs b/src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs index 30e7f2e743..968983adc3 100644 --- a/src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs +++ b/src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs @@ -43,9 +43,10 @@ namespace Umbraco.Tests.Persistence string path = TestHelper.CurrentAssemblyDirectory; AppDomain.CurrentDomain.SetData("DataDirectory", path); - - RepositoryResolver.Current = new RepositoryResolver(new RepositoryFactory(true, + + RepositoryResolver.Current = new RepositoryResolver(new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), _logger, + new SqlCeSyntaxProvider(), Mock.Of())); //disable cache diff --git a/src/Umbraco.Tests/Persistence/Caching/RuntimeCacheProviderTest.cs b/src/Umbraco.Tests/Persistence/Caching/RuntimeCacheProviderTest.cs index bbf4bc381a..4cba52a63c 100644 --- a/src/Umbraco.Tests/Persistence/Caching/RuntimeCacheProviderTest.cs +++ b/src/Umbraco.Tests/Persistence/Caching/RuntimeCacheProviderTest.cs @@ -1,138 +1,138 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using NUnit.Framework; -using Umbraco.Core; -using Umbraco.Core.Persistence.Caching; -using Umbraco.Tests.TestHelpers.Entities; +//using System; +//using System.Collections.Generic; +//using System.Linq; +//using NUnit.Framework; +//using Umbraco.Core; +//using Umbraco.Core.Persistence.Caching; +//using Umbraco.Tests.TestHelpers.Entities; -namespace Umbraco.Tests.Persistence.Caching -{ - [TestFixture] - public class RuntimeCacheProviderTest - { - private IRepositoryCacheProvider _registry; +//namespace Umbraco.Tests.Persistence.Caching +//{ +// [TestFixture] +// public class RuntimeCacheProviderTest +// { +// private IRepositoryCacheProvider _registry; - [SetUp] - public void Initiate_Registry() - { - _registry = RuntimeCacheProvider.Current; +// [SetUp] +// public void Initiate_Registry() +// { +// _registry = RuntimeCacheProvider.Current; - //Fill the registry with random entities - var entity1 = new MockedEntity { Id = 1, Key = 1.ToGuid(), Alias = "mocked1", Name = "Mocked1", Value = Guid.NewGuid().ToString("n") }; - var entity2 = new MockedEntity { Id = 2, Key = 2.ToGuid(), Alias = "mocked2", Name = "Mocked2", Value = Guid.NewGuid().ToString("n") }; - var entity3 = new MockedEntity { Id = 3, Key = 3.ToGuid(), Alias = "mocked3", Name = "Mocked3", Value = Guid.NewGuid().ToString("n") }; - var entity4 = new MockedEntity { Id = 4, Key = 4.ToGuid(), Alias = "mocked4", Name = "Mocked4", Value = Guid.NewGuid().ToString("n") }; - var entity5 = new MockedEntity { Id = 5, Key = 5.ToGuid(), Alias = "mocked5", Name = "Mocked5", Value = Guid.NewGuid().ToString("n") }; - var entity6 = new MockedEntity { Id = 6, Key = 6.ToGuid(), Alias = "mocked6", Name = "Mocked6", Value = Guid.NewGuid().ToString("n") }; +// //Fill the registry with random entities +// var entity1 = new MockedEntity { Id = 1, Key = 1.ToGuid(), Alias = "mocked1", Name = "Mocked1", Value = Guid.NewGuid().ToString("n") }; +// var entity2 = new MockedEntity { Id = 2, Key = 2.ToGuid(), Alias = "mocked2", Name = "Mocked2", Value = Guid.NewGuid().ToString("n") }; +// var entity3 = new MockedEntity { Id = 3, Key = 3.ToGuid(), Alias = "mocked3", Name = "Mocked3", Value = Guid.NewGuid().ToString("n") }; +// var entity4 = new MockedEntity { Id = 4, Key = 4.ToGuid(), Alias = "mocked4", Name = "Mocked4", Value = Guid.NewGuid().ToString("n") }; +// var entity5 = new MockedEntity { Id = 5, Key = 5.ToGuid(), Alias = "mocked5", Name = "Mocked5", Value = Guid.NewGuid().ToString("n") }; +// var entity6 = new MockedEntity { Id = 6, Key = 6.ToGuid(), Alias = "mocked6", Name = "Mocked6", Value = Guid.NewGuid().ToString("n") }; - _registry.Save(typeof(MockedEntity), entity1); - _registry.Save(typeof(MockedEntity), entity2); - _registry.Save(typeof(MockedEntity), entity3); - _registry.Save(typeof(MockedEntity), entity4); - _registry.Save(typeof(MockedEntity), entity5); - _registry.Save(typeof(MockedEntity), entity6); - } +// _registry.Save(typeof(MockedEntity), entity1); +// _registry.Save(typeof(MockedEntity), entity2); +// _registry.Save(typeof(MockedEntity), entity3); +// _registry.Save(typeof(MockedEntity), entity4); +// _registry.Save(typeof(MockedEntity), entity5); +// _registry.Save(typeof(MockedEntity), entity6); +// } - [Test] - public void Tracked_Keys_Removed_When_Cache_Removed() - { - _registry = RuntimeCacheProvider.Current; +// [Test] +// public void Tracked_Keys_Removed_When_Cache_Removed() +// { +// _registry = RuntimeCacheProvider.Current; - //Fill the registry with random entities - var entity1 = new MockedEntity { Id = 1, Key = 1.ToGuid(), Alias = "mocked1", Name = "Mocked1", Value = Guid.NewGuid().ToString("n") }; - var entity2 = new MockedEntity { Id = 2, Key = 2.ToGuid(), Alias = "mocked2", Name = "Mocked2", Value = Guid.NewGuid().ToString("n") }; - var entity3 = new MockedEntity { Id = 3, Key = 3.ToGuid(), Alias = "mocked3", Name = "Mocked3", Value = Guid.NewGuid().ToString("n") }; +// //Fill the registry with random entities +// var entity1 = new MockedEntity { Id = 1, Key = 1.ToGuid(), Alias = "mocked1", Name = "Mocked1", Value = Guid.NewGuid().ToString("n") }; +// var entity2 = new MockedEntity { Id = 2, Key = 2.ToGuid(), Alias = "mocked2", Name = "Mocked2", Value = Guid.NewGuid().ToString("n") }; +// var entity3 = new MockedEntity { Id = 3, Key = 3.ToGuid(), Alias = "mocked3", Name = "Mocked3", Value = Guid.NewGuid().ToString("n") }; - _registry.Save(typeof(MockedEntity), entity1); - _registry.Save(typeof(MockedEntity), entity2); - _registry.Save(typeof(MockedEntity), entity3); +// _registry.Save(typeof(MockedEntity), entity1); +// _registry.Save(typeof(MockedEntity), entity2); +// _registry.Save(typeof(MockedEntity), entity3); - //now clear the runtime cache internally - ((RuntimeCacheProvider)_registry).ClearDataCache(); +// //now clear the runtime cache internally +// ((RuntimeCacheProvider)_registry).ClearDataCache(); - Assert.AreEqual(0, _registry.GetAllByType(typeof (MockedEntity)).Count()); - } +// Assert.AreEqual(0, _registry.GetAllByType(typeof (MockedEntity)).Count()); +// } - [Test] - public void Can_Clear_By_Type() - { - var customObj1 = new CustomMockedEntity { Id = 5, Key = 5.ToGuid(), Alias = "mocked5", Name = "Mocked5", Value = Guid.NewGuid().ToString("n") }; - var customObj2 = new CustomMockedEntity { Id = 6, Key = 6.ToGuid(), Alias = "mocked6", Name = "Mocked6", Value = Guid.NewGuid().ToString("n") }; +// [Test] +// public void Can_Clear_By_Type() +// { +// var customObj1 = new CustomMockedEntity { Id = 5, Key = 5.ToGuid(), Alias = "mocked5", Name = "Mocked5", Value = Guid.NewGuid().ToString("n") }; +// var customObj2 = new CustomMockedEntity { Id = 6, Key = 6.ToGuid(), Alias = "mocked6", Name = "Mocked6", Value = Guid.NewGuid().ToString("n") }; - _registry.Save(typeof(CustomMockedEntity), customObj1); - _registry.Save(typeof(CustomMockedEntity), customObj2); +// _registry.Save(typeof(CustomMockedEntity), customObj1); +// _registry.Save(typeof(CustomMockedEntity), customObj2); - Assert.AreEqual(2, _registry.GetAllByType(typeof(CustomMockedEntity)).Count()); +// Assert.AreEqual(2, _registry.GetAllByType(typeof(CustomMockedEntity)).Count()); - _registry.Clear(typeof(CustomMockedEntity)); +// _registry.Clear(typeof(CustomMockedEntity)); - Assert.AreEqual(0, _registry.GetAllByType(typeof(CustomMockedEntity)).Count()); - } +// Assert.AreEqual(0, _registry.GetAllByType(typeof(CustomMockedEntity)).Count()); +// } - [Test] - public void Can_Get_Entity_From_Registry() - { - // Arrange - var mockedEntity = new MockedEntity { Id = 20, Key = 20.ToGuid(), Alias = "getMocked", Name = "GetMocked", Value = "Getting entity by id test" }; - _registry.Save(typeof(MockedEntity), mockedEntity); +// [Test] +// public void Can_Get_Entity_From_Registry() +// { +// // Arrange +// var mockedEntity = new MockedEntity { Id = 20, Key = 20.ToGuid(), Alias = "getMocked", Name = "GetMocked", Value = "Getting entity by id test" }; +// _registry.Save(typeof(MockedEntity), mockedEntity); - // Act - var entity = _registry.GetById(mockedEntity.GetType(), mockedEntity.Key); +// // Act +// var entity = _registry.GetById(mockedEntity.GetType(), mockedEntity.Key); - // Assert - Assert.That(entity, Is.Not.Null); - Assert.That(entity.Id, Is.EqualTo(mockedEntity.Id)); - Assert.That(entity.GetType(), Is.EqualTo(mockedEntity.GetType())); - } +// // Assert +// Assert.That(entity, Is.Not.Null); +// Assert.That(entity.Id, Is.EqualTo(mockedEntity.Id)); +// Assert.That(entity.GetType(), Is.EqualTo(mockedEntity.GetType())); +// } - [Test] - public void Can_Get_Entities_By_Ids_From_Registry() - { - // Arrange - var mockedEntity1 = new MockedEntity { Id = 30, Key = 30.ToGuid(), Alias = "getMocked1", Name = "GetMocked1", Value = "Entity 1 - Getting entity by ids test" }; - var mockedEntity2 = new MockedEntity { Id = 31, Key = 31.ToGuid(), Alias = "getMocked2", Name = "GetMocked2", Value = "Entity 2 - Getting entity by ids test" }; - _registry.Save(typeof(MockedEntity), mockedEntity1); - _registry.Save(typeof(MockedEntity), mockedEntity2); +// [Test] +// public void Can_Get_Entities_By_Ids_From_Registry() +// { +// // Arrange +// var mockedEntity1 = new MockedEntity { Id = 30, Key = 30.ToGuid(), Alias = "getMocked1", Name = "GetMocked1", Value = "Entity 1 - Getting entity by ids test" }; +// var mockedEntity2 = new MockedEntity { Id = 31, Key = 31.ToGuid(), Alias = "getMocked2", Name = "GetMocked2", Value = "Entity 2 - Getting entity by ids test" }; +// _registry.Save(typeof(MockedEntity), mockedEntity1); +// _registry.Save(typeof(MockedEntity), mockedEntity2); - // Act - var entities = _registry.GetByIds(typeof(MockedEntity), new List { mockedEntity1.Key, mockedEntity2.Key }).ToList(); +// // Act +// var entities = _registry.GetByIds(typeof(MockedEntity), new List { mockedEntity1.Key, mockedEntity2.Key }).ToList(); - // Assert - Assert.That(entities, Is.Not.Null); - Assert.That(entities.Count(), Is.EqualTo(2)); - Assert.That(entities.Any(x => x.Id == mockedEntity1.Id), Is.True); - Assert.That(entities.Any(x => x.Id == mockedEntity2.Id), Is.True); - } +// // Assert +// Assert.That(entities, Is.Not.Null); +// Assert.That(entities.Count(), Is.EqualTo(2)); +// Assert.That(entities.Any(x => x.Id == mockedEntity1.Id), Is.True); +// Assert.That(entities.Any(x => x.Id == mockedEntity2.Id), Is.True); +// } - [Test] - public void Can_Get_Entities_By_Type_From_Registry() - { - var entities = _registry.GetAllByType(typeof(MockedEntity)); +// [Test] +// public void Can_Get_Entities_By_Type_From_Registry() +// { +// var entities = _registry.GetAllByType(typeof(MockedEntity)); - Assert.That(entities, Is.Not.Null); - Assert.That(entities.Any(), Is.True); - Assert.That(entities.Count(), Is.GreaterThanOrEqualTo(6)); - } +// Assert.That(entities, Is.Not.Null); +// Assert.That(entities.Any(), Is.True); +// Assert.That(entities.Count(), Is.GreaterThanOrEqualTo(6)); +// } - [Test] - public void Can_Delete_Entity_From_Registry() - { - // Arrange - var mockedEntity = new MockedEntity { Id = 40, Key = 40.ToGuid(), Alias = "deleteMocked", Name = "DeleteMocked", Value = "Deleting entity test" }; - _registry.Save(typeof(MockedEntity), mockedEntity); - var entitiesBeforeDeletion = _registry.GetAllByType(typeof(MockedEntity)); - int countBefore = entitiesBeforeDeletion.Count(); +// [Test] +// public void Can_Delete_Entity_From_Registry() +// { +// // Arrange +// var mockedEntity = new MockedEntity { Id = 40, Key = 40.ToGuid(), Alias = "deleteMocked", Name = "DeleteMocked", Value = "Deleting entity test" }; +// _registry.Save(typeof(MockedEntity), mockedEntity); +// var entitiesBeforeDeletion = _registry.GetAllByType(typeof(MockedEntity)); +// int countBefore = entitiesBeforeDeletion.Count(); - // Act - var entity = _registry.GetById(mockedEntity.GetType(), mockedEntity.Key); - _registry.Delete(typeof(MockedEntity), entity); - var entitiesAfterDeletion = _registry.GetAllByType(typeof(MockedEntity)); - int countAfter = entitiesAfterDeletion.Count(); +// // Act +// var entity = _registry.GetById(mockedEntity.GetType(), mockedEntity.Key); +// _registry.Delete(typeof(MockedEntity), entity); +// var entitiesAfterDeletion = _registry.GetAllByType(typeof(MockedEntity)); +// int countAfter = entitiesAfterDeletion.Count(); - // Assert - Assert.That(countBefore, Is.GreaterThan(countAfter)); - Assert.That(entitiesAfterDeletion.Count(x => x.Id == mockedEntity.Id), Is.EqualTo(0)); - } - } -} \ No newline at end of file +// // Assert +// Assert.That(countBefore, Is.GreaterThan(countAfter)); +// Assert.That(entitiesAfterDeletion.Count(x => x.Id == mockedEntity.Id), Is.EqualTo(0)); +// } +// } +//} \ No newline at end of file diff --git a/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs index f163b2e870..d007f989ea 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs @@ -44,10 +44,10 @@ namespace Umbraco.Tests.Persistence.Repositories private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { - var templateRepository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); - var tagRepository = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), templateRepository); - var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); + var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); + var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), templateRepository); + var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); return repository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs index a14b8114c0..2cbfed1fd6 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs @@ -39,17 +39,17 @@ namespace Umbraco.Tests.Persistence.Repositories private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { - var templateRepository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); - var tagRepository = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), templateRepository); - var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); + var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); + var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), templateRepository); + var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); return repository; } private ContentTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - var templateRepository = new TemplateRepository(unitOfWork, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); - var contentTypeRepository = new ContentTypeRepository(unitOfWork, Mock.Of(), Mock.Of(), templateRepository); + var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); + var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), templateRepository); return contentTypeRepository; } @@ -75,7 +75,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var templateRepo = new TemplateRepository(unitOfWork, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of())) + using (var templateRepo = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of())) using (var repository = CreateRepository(unitOfWork)) { var templates = new[] diff --git a/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs index 478d59a8ef..6e0e53e2cf 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs @@ -34,11 +34,11 @@ namespace Umbraco.Tests.Persistence.Repositories private DataTypeDefinitionRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { var dataTypeDefinitionRepository = new DataTypeDefinitionRepository( - unitOfWork, NullCacheProvider.Current, + unitOfWork, CacheHelper.CreateDisabledCacheHelper(), CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), - new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), - new TemplateRepository(unitOfWork, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()))); + new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), + new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()))); return dataTypeDefinitionRepository; } @@ -375,11 +375,11 @@ namespace Umbraco.Tests.Persistence.Repositories var cache = new CacheHelper(new ObjectCacheRuntimeCacheProvider(), new StaticCacheProvider(), new StaticCacheProvider()); Func creator = () => new DataTypeDefinitionRepository( - unitOfWork, NullCacheProvider.Current, + unitOfWork, CacheHelper.CreateDisabledCacheHelper(), cache, Mock.Of(), - new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), - new TemplateRepository(unitOfWork, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()))); + new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), + new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()))); DataTypeDefinition dtd; using (var repository = creator()) @@ -414,11 +414,11 @@ namespace Umbraco.Tests.Persistence.Repositories var cache = new CacheHelper(new ObjectCacheRuntimeCacheProvider(), new StaticCacheProvider(), new StaticCacheProvider()); Func creator = () => new DataTypeDefinitionRepository( - unitOfWork, NullCacheProvider.Current, + unitOfWork, CacheHelper.CreateDisabledCacheHelper(), cache, Mock.Of(), - new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), - new TemplateRepository(unitOfWork, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()))); + new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), + new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()))); DataTypeDefinition dtd; using (var repository = creator()) diff --git a/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs index aa6bbdcfe2..7516a1b25c 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs @@ -2,12 +2,14 @@ using System.Linq; using Moq; using NUnit.Framework; +using Umbraco.Core; using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Persistence; using Umbraco.Core.Persistence.Caching; using Umbraco.Core.Persistence.Querying; using Umbraco.Core.Persistence.Repositories; +using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Persistence.UnitOfWork; using Umbraco.Tests.TestHelpers; @@ -27,8 +29,8 @@ namespace Umbraco.Tests.Persistence.Repositories private DictionaryRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out LanguageRepository languageRepository) { - languageRepository = new LanguageRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - var dictionaryRepository = new DictionaryRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), languageRepository); + languageRepository = new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var dictionaryRepository = new DictionaryRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), new SqlCeSyntaxProvider(), languageRepository); return dictionaryRepository; } @@ -46,6 +48,72 @@ namespace Umbraco.Tests.Persistence.Repositories Assert.That(repository, Is.Not.Null); } + [Test] + public void Can_Perform_Get_By_Key_On_DictionaryRepository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + LanguageRepository languageRepository; + using (var repository = CreateRepository(unitOfWork, out languageRepository)) + { + var dictionaryItem = (IDictionaryItem)new DictionaryItem("Testing1235") + { + Translations = new List + { + new DictionaryTranslation(ServiceContext.LocalizationService.GetLanguageByCultureCode("en-US"), "Hello world") + } + }; + + repository.AddOrUpdate(dictionaryItem); + unitOfWork.Commit(); + + //re-get + dictionaryItem = repository.Get("Testing1235"); + + // Assert + Assert.That(dictionaryItem, Is.Not.Null); + Assert.That(dictionaryItem.ItemKey, Is.EqualTo("Testing1235")); + Assert.That(dictionaryItem.Translations.Any(), Is.True); + Assert.That(dictionaryItem.Translations.Any(x => x == null), Is.False); + Assert.That(dictionaryItem.Translations.First().Value, Is.EqualTo("Hello world")); + } + + } + + [Test] + public void Can_Perform_Get_By_UniqueId_On_DictionaryRepository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + LanguageRepository languageRepository; + using (var repository = CreateRepository(unitOfWork, out languageRepository)) + { + var dictionaryItem = (IDictionaryItem)new DictionaryItem("Testing1235") + { + Translations = new List + { + new DictionaryTranslation(ServiceContext.LocalizationService.GetLanguageByCultureCode("en-US"), "Hello world") + } + }; + + repository.AddOrUpdate(dictionaryItem); + unitOfWork.Commit(); + + //re-get + dictionaryItem = repository.Get(dictionaryItem.Key); + + // Assert + Assert.That(dictionaryItem, Is.Not.Null); + Assert.That(dictionaryItem.ItemKey, Is.EqualTo("Testing1235")); + Assert.That(dictionaryItem.Translations.Any(), Is.True); + Assert.That(dictionaryItem.Translations.Any(x => x == null), Is.False); + Assert.That(dictionaryItem.Translations.First().Value, Is.EqualTo("Hello world")); + } + + } + [Test] public void Can_Perform_Get_On_DictionaryRepository() { @@ -286,8 +354,8 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - var languageRepository = new LanguageRepository(unitOfWork, Mock.Of(), Mock.Of()); - var repository = new DictionaryRepository(unitOfWork, Mock.Of(), Mock.Of(), languageRepository); + var languageRepository = new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var repository = new DictionaryRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), new SqlCeSyntaxProvider(), languageRepository); var languageNo = new Language("nb-NO") { CultureName = "nb-NO" }; ServiceContext.LocalizationService.Save(languageNo); diff --git a/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs index c295c7fb66..4d0a235a3d 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs @@ -1,6 +1,8 @@ -using System.Linq; +using System.Globalization; +using System.Linq; using Moq; using NUnit.Framework; +using Umbraco.Core; using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Persistence; @@ -26,7 +28,7 @@ namespace Umbraco.Tests.Persistence.Repositories private LanguageRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new LanguageRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); + return new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); } [Test] @@ -62,6 +64,58 @@ namespace Umbraco.Tests.Persistence.Repositories } } + [Test] + public void Can_Perform_Get_By_Iso_Code_On_LanguageRepository() + { + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + using (var repository = CreateRepository(unitOfWork)) + { + var au = CultureInfo.GetCultureInfo("en-AU"); + var language = (ILanguage)new Language(au.Name) + { + CultureName = au.DisplayName + }; + repository.AddOrUpdate(language); + unitOfWork.Commit(); + + //re-get + language = repository.GetByIsoCode(au.Name); + + // Assert + Assert.That(language, Is.Not.Null); + Assert.That(language.HasIdentity, Is.True); + Assert.That(language.CultureName, Is.EqualTo(au.DisplayName)); + Assert.That(language.IsoCode, Is.EqualTo(au.Name)); + } + } + + [Test] + public void Can_Perform_Get_By_Culture_Name_On_LanguageRepository() + { + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + using (var repository = CreateRepository(unitOfWork)) + { + var au = CultureInfo.GetCultureInfo("en-AU"); + var language = (ILanguage)new Language(au.Name) + { + CultureName = au.DisplayName + }; + repository.AddOrUpdate(language); + unitOfWork.Commit(); + + //re-get + language = repository.GetByCultureName(au.DisplayName); + + // Assert + Assert.That(language, Is.Not.Null); + Assert.That(language.HasIdentity, Is.True); + Assert.That(language.CultureName, Is.EqualTo(au.DisplayName)); + Assert.That(language.IsoCode, Is.EqualTo(au.Name)); + } + } + [Test] public void Get_WhenIdDoesntExist_ReturnsNull() { diff --git a/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs index e9c71c349d..bcefa91867 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs @@ -2,6 +2,7 @@ using System.Linq; using Moq; using NUnit.Framework; +using Umbraco.Core; using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Persistence; @@ -33,7 +34,7 @@ namespace Umbraco.Tests.Persistence.Repositories var unitOfWork = provider.GetUnitOfWork(); // Act - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { var macro = new Macro("test1", "Test", "~/usercontrol/blah.ascx", "MyAssembly", "test.xslt", "~/views/macropartials/test.cshtml"); repository.AddOrUpdate(macro); @@ -51,7 +52,7 @@ namespace Umbraco.Tests.Persistence.Repositories var unitOfWork = provider.GetUnitOfWork(); // Act - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { var macro = repository.Get(1); macro.Alias = "test2"; @@ -69,7 +70,7 @@ namespace Umbraco.Tests.Persistence.Repositories var unitOfWork = provider.GetUnitOfWork(); // Act - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { // Assert Assert.That(repository, Is.Not.Null); @@ -82,7 +83,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { // Act var macro = repository.Get(1); @@ -112,7 +113,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { // Act var macros = repository.GetAll(); @@ -129,7 +130,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { // Act var query = Query.Builder.Where(x => x.Alias.ToUpper() == "TEST1"); @@ -146,7 +147,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { // Act var query = Query.Builder.Where(x => x.Name.StartsWith("Test")); @@ -163,7 +164,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { // Act var macro = new Macro("test", "Test", "~/usercontrol/blah.ascx", "MyAssembly", "test.xslt", "~/views/macropartials/test.cshtml"); @@ -184,7 +185,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { // Act var macro = repository.Get(2); @@ -225,7 +226,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { // Act var macro = repository.Get(3); @@ -246,7 +247,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { // Act var exists = repository.Exists(3); @@ -264,7 +265,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { var macro = repository.Get(1); macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test")); @@ -291,7 +292,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { var macro = new Macro("newmacro", "A new macro", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml"); macro.Properties.Add(new MacroProperty("blah1", "New1", 4, "test.editor")); @@ -316,7 +317,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { var macro = new Macro("newmacro", "A new macro", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml"); macro.Properties.Add(new MacroProperty("blah1", "New1", 4, "test.editor")); @@ -341,7 +342,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { var macro = new Macro("newmacro", "A new macro", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml"); var prop1 = new MacroProperty("blah1", "New1", 4, "test.editor"); @@ -372,7 +373,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { var macro = repository.Get(1); macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test")); @@ -400,7 +401,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new MacroRepository(unitOfWork, NullCacheProvider.Current, Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { var macro = repository.Get(1); macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test")); @@ -429,7 +430,7 @@ namespace Umbraco.Tests.Persistence.Repositories { var provider = new PetaPocoUnitOfWorkProvider(Logger); using (var unitOfWork = provider.GetUnitOfWork()) - using (var repository = new MacroRepository(unitOfWork, Mock.Of(), Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { repository.AddOrUpdate(new Macro("test1", "Test1", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml")); repository.AddOrUpdate(new Macro("test2", "Test2", "~/usercontrol/test2.ascx", "MyAssembly2", "test2.xslt", "~/views/macropartials/test2.cshtml")); diff --git a/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs index ab0e5661c6..d691212475 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs @@ -40,9 +40,9 @@ namespace Umbraco.Tests.Persistence.Repositories private MediaRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository) { - mediaTypeRepository = new MediaTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - var tagRepository = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - var repository = new MediaRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), mediaTypeRepository, tagRepository); + mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var repository = new MediaRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), mediaTypeRepository, tagRepository); return repository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs index d14b5c4047..24802a2ca0 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs @@ -27,7 +27,7 @@ namespace Umbraco.Tests.Persistence.Repositories private MediaTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new MediaTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); + return new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); } [Test] diff --git a/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs index b3837c7cda..6052e068c0 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs @@ -35,10 +35,10 @@ namespace Umbraco.Tests.Persistence.Repositories private MemberRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MemberTypeRepository memberTypeRepository, out MemberGroupRepository memberGroupRepository) { - memberTypeRepository = new MemberTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - memberGroupRepository = new MemberGroupRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), CacheHelper.CreateDisabledCacheHelper()); - var tagRepo = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - var repository = new MemberRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), memberTypeRepository, memberGroupRepository, tagRepo); + memberTypeRepository = new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + memberGroupRepository = new MemberGroupRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), CacheHelper.CreateDisabledCacheHelper()); + var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var repository = new MemberRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), memberTypeRepository, memberGroupRepository, tagRepo); return repository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs index 7899aafd02..287bcebf57 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs @@ -32,7 +32,7 @@ namespace Umbraco.Tests.Persistence.Repositories private MemberTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new MemberTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); + return new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); } [Test] diff --git a/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs index 20cec1848d..58066d80fc 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs @@ -32,8 +32,8 @@ namespace Umbraco.Tests.Persistence.Repositories private RelationRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out RelationTypeRepository relationTypeRepository) { - relationTypeRepository = new RelationTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), relationTypeRepository); + relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var repository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), relationTypeRepository); return repository; } @@ -281,8 +281,8 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - var relationTypeRepository = new RelationTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - var relationRepository = new RelationRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), relationTypeRepository); + var relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var relationRepository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), relationTypeRepository); relationTypeRepository.AddOrUpdate(relateContent); relationTypeRepository.AddOrUpdate(relateContentType); diff --git a/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs index 3d58e09e19..91cf2c1b61 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs @@ -29,7 +29,7 @@ namespace Umbraco.Tests.Persistence.Repositories private RelationTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new RelationTypeRepository(unitOfWork, Mock.Of(), Mock.Of()); + return new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); } [Test] @@ -248,7 +248,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - var repository = new RelationTypeRepository(unitOfWork, Mock.Of(), Mock.Of()); + var repository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); repository.AddOrUpdate(relateContent);//Id 2 repository.AddOrUpdate(relateContentType);//Id 3 diff --git a/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs index 4b8a99c05a..4acef9bc74 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs @@ -3,6 +3,7 @@ using System.Data.SqlServerCe; using System.Linq; using Moq; using NUnit.Framework; +using Umbraco.Core; using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Caching; @@ -27,7 +28,7 @@ namespace Umbraco.Tests.Persistence.Repositories private ServerRegistrationRepository CreateRepositor(IDatabaseUnitOfWork unitOfWork) { - return new ServerRegistrationRepository(unitOfWork, Mock.Of(), Mock.Of()); + return new ServerRegistrationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); } [Test] @@ -245,7 +246,7 @@ namespace Umbraco.Tests.Persistence.Repositories { var provider = new PetaPocoUnitOfWorkProvider(Logger); using (var unitOfWork = provider.GetUnitOfWork()) - using (var repository = new ServerRegistrationRepository(unitOfWork, Mock.Of(), Mock.Of())) + using (var repository = new ServerRegistrationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { repository.AddOrUpdate(new ServerRegistration("http://localhost", "COMPUTER1", DateTime.Now) { IsActive = true }); repository.AddOrUpdate(new ServerRegistration("http://www.mydomain.com", "COMPUTER2", DateTime.Now)); diff --git a/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs index 5e80bff8c0..597774a226 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs @@ -35,7 +35,7 @@ namespace Umbraco.Tests.Persistence.Repositories private TagRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - var tagRepository = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); + var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); return tagRepository; } @@ -953,18 +953,18 @@ namespace Umbraco.Tests.Persistence.Repositories private ContentRepository CreateContentRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { - var templateRepository = new TemplateRepository(unitOfWork, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); - var tagRepository = new TagRepository(unitOfWork, Mock.Of(), Mock.Of()); - contentTypeRepository = new ContentTypeRepository(unitOfWork, Mock.Of(), Mock.Of(), templateRepository); - var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); + var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()); + var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), templateRepository); + var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); return repository; } private MediaRepository CreateMediaRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository) { - var tagRepository = new TagRepository(unitOfWork, Mock.Of(), Mock.Of()); - mediaTypeRepository = new MediaTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - var repository = new MediaRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), mediaTypeRepository, tagRepository); + var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var repository = new MediaRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), mediaTypeRepository, tagRepository); return repository; } } diff --git a/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs index 0aa1117cdb..b577378d9f 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs @@ -60,7 +60,7 @@ namespace Umbraco.Tests.Persistence.Repositories var unitOfWork = provider.GetUnitOfWork(); // Act - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { @@ -76,7 +76,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { // Act @@ -102,7 +102,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { // Act @@ -129,7 +129,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { //NOTE: This has to be persisted first @@ -159,7 +159,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { // Act @@ -180,7 +180,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { // Act @@ -208,7 +208,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { //NOTE: This has to be persisted first @@ -239,7 +239,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { // Act @@ -269,7 +269,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { // Act @@ -305,7 +305,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { // Act @@ -336,7 +336,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { // Act @@ -367,7 +367,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { var template = new Template("test", "test", _viewsFileSystem, _masterPageFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)) @@ -397,7 +397,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { var template = new Template("test", "test", _viewsFileSystem, _masterPageFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)) @@ -428,12 +428,12 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var templateRepository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { - var tagRepository = new TagRepository(unitOfWork, Mock.Of(), Mock.Of()); - var contentTypeRepository = new ContentTypeRepository(unitOfWork, Mock.Of(), Mock.Of(), templateRepository); - var contentRepo = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); + var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), templateRepository); + var contentRepo = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); using (contentRepo) { @@ -473,7 +473,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { var parent = new Template("parent", "parent", _viewsFileSystem, _masterPageFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)) @@ -515,7 +515,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { var parent = new Template("parent", "parent", _viewsFileSystem, _masterPageFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)) @@ -614,7 +614,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { var parent = new Template("parent", "parent", _viewsFileSystem, _masterPageFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)); @@ -679,7 +679,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); - using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), _masterPageFileSystem, _viewsFileSystem, + using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), _masterPageFileSystem, _viewsFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc))) { var parent = new Template("parent", "parent", _viewsFileSystem, _masterPageFileSystem, Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)); diff --git a/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs index b8845e2a02..e552168b5d 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs @@ -34,8 +34,8 @@ namespace Umbraco.Tests.Persistence.Repositories private UserRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out UserTypeRepository userTypeRepository) { - userTypeRepository = new UserTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of()); - var repository = new UserRepository(unitOfWork, NullCacheProvider.Current, Mock.Of(), userTypeRepository, CacheHelper.CreateDisabledCacheHelper()); + userTypeRepository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); + var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), userTypeRepository, CacheHelper.CreateDisabledCacheHelper()); return repository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs index a6a877a9de..fe9275d167 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs @@ -1,6 +1,7 @@ using System.Linq; using Moq; using NUnit.Framework; +using Umbraco.Core; using Umbraco.Core.Logging; using Umbraco.Core.Models.Membership; using Umbraco.Core.Persistence; @@ -31,7 +32,7 @@ namespace Umbraco.Tests.Persistence.Repositories private UserTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new UserTypeRepository(unitOfWork, Mock.Of(), Mock.Of()); + return new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of()); } [Test] diff --git a/src/Umbraco.Tests/Persistence/RepositoryResolverTests.cs b/src/Umbraco.Tests/Persistence/RepositoryResolverTests.cs index 40f9b524d4..be387cc339 100644 --- a/src/Umbraco.Tests/Persistence/RepositoryResolverTests.cs +++ b/src/Umbraco.Tests/Persistence/RepositoryResolverTests.cs @@ -10,6 +10,7 @@ using Umbraco.Core.Models.Membership; using Umbraco.Core.ObjectResolution; using Umbraco.Core.Persistence; using Umbraco.Core.Persistence.Repositories; +using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Persistence.UnitOfWork; using Umbraco.Tests.TestHelpers; @@ -23,8 +24,9 @@ namespace Umbraco.Tests.Persistence public void Setup() { RepositoryResolver.Current = new RepositoryResolver( - new RepositoryFactory(true, //disable all repo caches for tests! + new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), //disable all repo caches for tests! Mock.Of(), + new SqlCeSyntaxProvider(), SettingsForTests.GenerateMockSettings())); Resolution.Freeze(); diff --git a/src/Umbraco.Tests/Services/MacroServiceTests.cs b/src/Umbraco.Tests/Services/MacroServiceTests.cs index 2fdcbb5d7c..9af3f9f5e0 100644 --- a/src/Umbraco.Tests/Services/MacroServiceTests.cs +++ b/src/Umbraco.Tests/Services/MacroServiceTests.cs @@ -1,6 +1,7 @@ using System.Linq; using Moq; using NUnit.Framework; +using Umbraco.Core; using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Caching; @@ -26,7 +27,7 @@ namespace Umbraco.Tests.Services var provider = new PetaPocoUnitOfWorkProvider(Logger); using (var unitOfWork = provider.GetUnitOfWork()) - using (var repository = new MacroRepository(unitOfWork, Mock.Of(), Mock.Of())) + using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of())) { repository.AddOrUpdate(new Macro("test1", "Test1", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml")); repository.AddOrUpdate(new Macro("test2", "Test2", "~/usercontrol/test2.ascx", "MyAssembly2", "test2.xslt", "~/views/macropartials/test2.cshtml")); diff --git a/src/Umbraco.Tests/Services/PerformanceTests.cs b/src/Umbraco.Tests/Services/PerformanceTests.cs index 7e754b6635..f38fbac92b 100644 --- a/src/Umbraco.Tests/Services/PerformanceTests.cs +++ b/src/Umbraco.Tests/Services/PerformanceTests.cs @@ -75,8 +75,6 @@ namespace Umbraco.Tests.Services //do this 10x! for (var i = 0; i < 10; i++) { - //clear the cache to make this test valid - RuntimeCacheProvider.Current.Clear(); var published = new List(); //get all content items that are published @@ -97,8 +95,6 @@ namespace Umbraco.Tests.Services //do this 10x! for (var i = 0; i < 10; i++) { - //clear the cache to make this test valid - RuntimeCacheProvider.Current.Clear(); //get all content items that are published var published = contentSvc.GetAllPublished(); @@ -122,8 +118,7 @@ namespace Umbraco.Tests.Services //do this 10x! for (var i = 0; i < 10; i++) { - //clear the cache to make this test valid - RuntimeCacheProvider.Current.Clear(); + //get all content items that are published of this type var published = contentSvc.GetContentOfContentType(contentTypeId).Where(content => content.Published); Assert.AreEqual(countOfPublished, published.Count(x => x.ContentTypeId == contentTypeId)); @@ -136,8 +131,6 @@ namespace Umbraco.Tests.Services //do this 10x! for (var i = 0; i < 10; i++) { - //clear the cache to make this test valid - RuntimeCacheProvider.Current.Clear(); //get all content items that are published of this type var published = contentSvc.GetPublishedContentOfContentType(contentTypeId); Assert.AreEqual(countOfPublished, published.Count(x => x.ContentTypeId == contentTypeId)); diff --git a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs index 3ebdefe752..8e4715e9d5 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs @@ -205,8 +205,9 @@ namespace Umbraco.Tests.TestHelpers () => PluginManager.Current.ResolveDataTypes()); RepositoryResolver.Current = new RepositoryResolver( - new RepositoryFactory(true, //disable all repo caches for tests! + new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), //disable all repo caches for tests! Logger, + SqlSyntaxProvider, SettingsForTests.GenerateMockSettings())); SqlSyntaxProvidersResolver.Current = new SqlSyntaxProvidersResolver( diff --git a/src/Umbraco.Tests/TestHelpers/BaseDatabaseTest.cs b/src/Umbraco.Tests/TestHelpers/BaseDatabaseTest.cs index cd0f8181fe..7a62b5f5df 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseDatabaseTest.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseDatabaseTest.cs @@ -61,8 +61,9 @@ namespace Umbraco.Tests.TestHelpers RepositoryResolver.Current = new RepositoryResolver( - new RepositoryFactory(true,//disable all repo caches for tests! + new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(),//disable all repo caches for tests! Logger, + SyntaxProvider, Mock.Of())); SqlSyntaxProvidersResolver.Current = new SqlSyntaxProvidersResolver( diff --git a/src/Umbraco.Web/Cache/ContentTypeCacheRefresher.cs b/src/Umbraco.Web/Cache/ContentTypeCacheRefresher.cs index 3db1e30fa7..6edeb98911 100644 --- a/src/Umbraco.Web/Cache/ContentTypeCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/ContentTypeCacheRefresher.cs @@ -126,8 +126,10 @@ namespace Umbraco.Web.Cache public override void RefreshAll() { - RuntimeCacheProvider.Current.Clear(typeof(IContent)); - RuntimeCacheProvider.Current.Clear(typeof(IContentType)); + //RuntimeCacheProvider.Current.Clear(typeof(IContent)); + //RuntimeCacheProvider.Current.Clear(typeof(IContentType)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); //all property type cache ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch(CacheKeys.PropertyTypeCacheKey); @@ -212,18 +214,18 @@ namespace Umbraco.Web.Cache { if (payloads.Any(x => x.Type == typeof (IContentType).Name)) { - RuntimeCacheProvider.Current.Clear(typeof(IContent)); - RuntimeCacheProvider.Current.Clear(typeof(IContentType)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); } if (payloads.Any(x => x.Type == typeof(IMediaType).Name)) { - RuntimeCacheProvider.Current.Clear(typeof(IMedia)); - RuntimeCacheProvider.Current.Clear(typeof(IMediaType)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); } if (payloads.Any(x => x.Type == typeof(IMemberType).Name)) { - RuntimeCacheProvider.Current.Clear(typeof(IMember)); - RuntimeCacheProvider.Current.Clear(typeof(IMemberType)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); } diff --git a/src/Umbraco.Web/Cache/DataTypeCacheRefresher.cs b/src/Umbraco.Web/Cache/DataTypeCacheRefresher.cs index f91c08b455..fb43268834 100644 --- a/src/Umbraco.Web/Cache/DataTypeCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/DataTypeCacheRefresher.cs @@ -119,12 +119,19 @@ namespace Umbraco.Web.Cache //we need to clear the ContentType runtime cache since that is what caches the // db data type to store the value against and anytime a datatype changes, this also might change // we basically need to clear all sorts of runtime caches here because so many things depend upon a data type - RuntimeCacheProvider.Current.Clear(typeof(IContent)); - RuntimeCacheProvider.Current.Clear(typeof (IContentType)); - RuntimeCacheProvider.Current.Clear(typeof(IMedia)); - RuntimeCacheProvider.Current.Clear(typeof(IMediaType)); - RuntimeCacheProvider.Current.Clear(typeof(IMember)); - RuntimeCacheProvider.Current.Clear(typeof(IMemberType)); + + //RuntimeCacheProvider.Current.Clear(typeof(IContent)); + //RuntimeCacheProvider.Current.Clear(typeof (IContentType)); + //RuntimeCacheProvider.Current.Clear(typeof(IMedia)); + //RuntimeCacheProvider.Current.Clear(typeof(IMediaType)); + //RuntimeCacheProvider.Current.Clear(typeof(IMember)); + //RuntimeCacheProvider.Current.Clear(typeof(IMemberType)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); payloads.ForEach(payload => { diff --git a/src/Umbraco.Web/Cache/DictionaryCacheRefresher.cs b/src/Umbraco.Web/Cache/DictionaryCacheRefresher.cs index 02c9a3656f..8e8236ad55 100644 --- a/src/Umbraco.Web/Cache/DictionaryCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/DictionaryCacheRefresher.cs @@ -1,4 +1,5 @@ using System; +using Umbraco.Core; using Umbraco.Core.Cache; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Caching; @@ -27,7 +28,8 @@ namespace Umbraco.Web.Cache public override void Refresh(int id) { - RuntimeCacheProvider.Current.Clear(typeof(IDictionaryItem)); + //RuntimeCacheProvider.Current.Clear(typeof(IDictionaryItem)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); //global::umbraco.cms.businesslogic.Dictionary.ClearCache(); //when a dictionary item is updated we must also clear the text cache! //global::umbraco.cms.businesslogic.language.Item.ClearCache(); @@ -36,7 +38,8 @@ namespace Umbraco.Web.Cache public override void Remove(int id) { - RuntimeCacheProvider.Current.Clear(typeof(IDictionaryItem)); + //RuntimeCacheProvider.Current.Clear(typeof(IDictionaryItem)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); //global::umbraco.cms.businesslogic.Dictionary.ClearCache(); //when a dictionary item is removed we must also clear the text cache! //global::umbraco.cms.businesslogic.language.Item.ClearCache(); diff --git a/src/Umbraco.Web/Cache/LanguageCacheRefresher.cs b/src/Umbraco.Web/Cache/LanguageCacheRefresher.cs index 33ff1f7237..43f69061cd 100644 --- a/src/Umbraco.Web/Cache/LanguageCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/LanguageCacheRefresher.cs @@ -28,13 +28,15 @@ namespace Umbraco.Web.Cache public override void Refresh(int id) { - RuntimeCacheProvider.Current.Clear(typeof(ILanguage)); + //RuntimeCacheProvider.Current.Clear(typeof(ILanguage)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); base.Refresh(id); } public override void Remove(int id) { - RuntimeCacheProvider.Current.Clear(typeof(ILanguage)); + //RuntimeCacheProvider.Current.Clear(typeof(ILanguage)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); //when a language is removed we must also clear the text cache! //global::umbraco.cms.businesslogic.language.Item.ClearCache(); base.Remove(id); diff --git a/src/Umbraco.Web/Cache/MacroCacheRefresher.cs b/src/Umbraco.Web/Cache/MacroCacheRefresher.cs index 19f56997ac..42c6063a70 100644 --- a/src/Umbraco.Web/Cache/MacroCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/MacroCacheRefresher.cs @@ -5,6 +5,7 @@ using Umbraco.Core.Cache; using Umbraco.Core.Models; using umbraco; using Umbraco.Core.Persistence.Caching; +using Umbraco.Core.Persistence.Repositories; using umbraco.interfaces; using System.Linq; using Macro = umbraco.cms.businesslogic.macro.Macro; @@ -170,12 +171,13 @@ namespace Umbraco.Web.Cache public override void RefreshAll() { - ApplicationContext.Current.ApplicationCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); GetAllMacroCacheKeys().ForEach( prefix => - ApplicationContext.Current.ApplicationCache.ClearCacheByKeySearch(prefix)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch(prefix)); - RuntimeCacheProvider.Current.Clear(typeof (IMacro)); + //RuntimeCacheProvider.Current.Clear(typeof (IMacro)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); base.RefreshAll(); } @@ -188,9 +190,10 @@ namespace Umbraco.Web.Cache { GetCacheKeysForAlias(payload.Alias).ForEach( alias => - ApplicationContext.Current.ApplicationCache.ClearCacheByKeySearch(alias)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch(alias)); - RuntimeCacheProvider.Current.Delete(typeof(IMacro), payload.Id); + //RuntimeCacheProvider.Current.Delete(typeof(IMacro), payload.Id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(payload.Id)); }); base.Refresh(jsonPayload); diff --git a/src/Umbraco.Web/Cache/MediaCacheRefresher.cs b/src/Umbraco.Web/Cache/MediaCacheRefresher.cs index bd12261b44..7e36989876 100644 --- a/src/Umbraco.Web/Cache/MediaCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/MediaCacheRefresher.cs @@ -8,6 +8,7 @@ using Umbraco.Core.Events; using Umbraco.Core.IO; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Caching; +using Umbraco.Core.Persistence.Repositories; using umbraco.interfaces; using System.Linq; @@ -160,7 +161,7 @@ namespace Umbraco.Web.Cache //if there's no path, then just use id (this will occur on permanent deletion like emptying recycle bin) if (payload.Path.IsNullOrWhiteSpace()) { - ApplicationContext.Current.ApplicationCache.ClearCacheByKeySearch( + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch( string.Format("{0}_{1}", CacheKeys.MediaCacheKey, payload.Id)); } else @@ -170,15 +171,17 @@ namespace Umbraco.Web.Cache int idPartAsInt; if (int.TryParse(idPart, out idPartAsInt)) { - RuntimeCacheProvider.Current.Delete(typeof(IMedia), idPartAsInt); + //RuntimeCacheProvider.Current.Delete(typeof(IMedia), idPartAsInt); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem( + RepositoryBase.GetCacheIdKey(idPartAsInt)); } - ApplicationContext.Current.ApplicationCache.ClearCacheByKeySearch( + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch( string.Format("{0}_{1}_True", CacheKeys.MediaCacheKey, idPart)); // Also clear calls that only query this specific item! if (idPart == payload.Id.ToString(CultureInfo.InvariantCulture)) - ApplicationContext.Current.ApplicationCache.ClearCacheByKeySearch( + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch( string.Format("{0}_{1}", CacheKeys.MediaCacheKey, payload.Id)); } diff --git a/src/Umbraco.Web/Cache/MemberCacheRefresher.cs b/src/Umbraco.Web/Cache/MemberCacheRefresher.cs index 97afd092a7..58be13e72a 100644 --- a/src/Umbraco.Web/Cache/MemberCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/MemberCacheRefresher.cs @@ -2,8 +2,10 @@ using Umbraco.Core; using Umbraco.Core.Cache; using Umbraco.Core.Models; +using Umbraco.Core.Models.Membership; using Umbraco.Core.Persistence.Caching; using umbraco.cms.businesslogic.member; +using Umbraco.Core.Persistence.Repositories; using umbraco.interfaces; namespace Umbraco.Web.Cache @@ -60,12 +62,13 @@ namespace Umbraco.Web.Cache { ApplicationContext.Current.ApplicationCache.ClearPartialViewCache(); - ApplicationContext.Current.ApplicationCache. + ApplicationContext.Current.ApplicationCache.RuntimeCache. ClearCacheByKeySearch(string.Format("{0}_{1}", CacheKeys.MemberLibraryCacheKey, id)); - ApplicationContext.Current.ApplicationCache. + ApplicationContext.Current.ApplicationCache.RuntimeCache. ClearCacheByKeySearch(string.Format("{0}{1}", CacheKeys.MemberBusinessLogicCacheKey, id)); - RuntimeCacheProvider.Current.Delete(typeof(IMember), id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(id)); + //RuntimeCacheProvider.Current.Delete(typeof(IMember), id); } } } \ No newline at end of file diff --git a/src/Umbraco.Web/Cache/MemberGroupCacheRefresher.cs b/src/Umbraco.Web/Cache/MemberGroupCacheRefresher.cs index df3b936207..460ed0d905 100644 --- a/src/Umbraco.Web/Cache/MemberGroupCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/MemberGroupCacheRefresher.cs @@ -5,6 +5,7 @@ using Umbraco.Core; using Umbraco.Core.Cache; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Caching; +using Umbraco.Core.Persistence.Repositories; namespace Umbraco.Web.Cache { @@ -109,7 +110,8 @@ namespace Umbraco.Web.Cache { ApplicationContext.Current.ApplicationCache.RuntimeCache .ClearCacheByKeySearch(string.Format("{0}.{1}", typeof(IMemberGroup).FullName, payload.Name)); - RuntimeCacheProvider.Current.Delete(typeof(IMemberGroup), payload.Id); + //RuntimeCacheProvider.Current.Delete(typeof(IMemberGroup), payload.Id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(payload.Id)); } }); diff --git a/src/Umbraco.Web/Cache/TemplateCacheRefresher.cs b/src/Umbraco.Web/Cache/TemplateCacheRefresher.cs index 42026a7523..6cc3a1ab86 100644 --- a/src/Umbraco.Web/Cache/TemplateCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/TemplateCacheRefresher.cs @@ -52,15 +52,16 @@ namespace Umbraco.Web.Cache private void RemoveFromCache(int id) { - ApplicationContext.Current.ApplicationCache.ClearCacheItem( + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem( string.Format("{0}{1}", CacheKeys.TemplateFrontEndCacheKey, id)); - ApplicationContext.Current.ApplicationCache.ClearCacheItem( + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem( string.Format("{0}{1}", CacheKeys.TemplateBusinessLogicCacheKey, id)); //need to clear the runtime cache for template instances //NOTE: This is temp until we implement the correct ApplicationCache and then we can remove the RuntimeCache, etc... - RuntimeCacheProvider.Current.Clear(typeof(ITemplate)); + //RuntimeCacheProvider.Current.Clear(typeof(ITemplate)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); } } diff --git a/src/Umbraco.Web/Cache/UnpublishedPageCacheRefresher.cs b/src/Umbraco.Web/Cache/UnpublishedPageCacheRefresher.cs index cce6f3f878..41eb251e0f 100644 --- a/src/Umbraco.Web/Cache/UnpublishedPageCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/UnpublishedPageCacheRefresher.cs @@ -1,10 +1,12 @@ using System; using System.Web.Script.Serialization; using umbraco; +using Umbraco.Core; using Umbraco.Core.Cache; using Umbraco.Core.Models; using System.Linq; using Umbraco.Core.Persistence.Caching; +using Umbraco.Core.Persistence.Repositories; using Umbraco.Core.Sync; namespace Umbraco.Web.Cache @@ -75,34 +77,39 @@ namespace Umbraco.Web.Cache public override void RefreshAll() { - RuntimeCacheProvider.Current.Clear(typeof(IContent)); + //RuntimeCacheProvider.Current.Clear(typeof(IContent)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); base.RefreshAll(); } public override void Refresh(int id) { - RuntimeCacheProvider.Current.Delete(typeof(IContent), id); + //RuntimeCacheProvider.Current.Delete(typeof(IContent), id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(id)); content.Instance.UpdateSortOrder(id); base.Refresh(id); } public override void Remove(int id) { - RuntimeCacheProvider.Current.Delete(typeof(IContent), id); + //RuntimeCacheProvider.Current.Delete(typeof(IContent), id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(id)); base.Remove(id); } public override void Refresh(IContent instance) { - RuntimeCacheProvider.Current.Delete(typeof(IContent), instance.Id); + //RuntimeCacheProvider.Current.Delete(typeof(IContent), instance.Id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(instance.Id)); content.Instance.UpdateSortOrder(instance); base.Refresh(instance); } public override void Remove(IContent instance) { - RuntimeCacheProvider.Current.Delete(typeof(IContent), instance.Id); + //RuntimeCacheProvider.Current.Delete(typeof(IContent), instance.Id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(instance.Id)); base.Remove(instance); } @@ -114,7 +121,8 @@ namespace Umbraco.Web.Cache { foreach (var payload in DeserializeFromJsonPayload(jsonPayload)) { - RuntimeCacheProvider.Current.Delete(typeof(IContent), payload.Id); + //RuntimeCacheProvider.Current.Delete(typeof(IContent), payload.Id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(payload.Id)); content.Instance.UpdateSortOrder(payload.Id); } diff --git a/src/Umbraco.Web/Cache/UserCacheRefresher.cs b/src/Umbraco.Web/Cache/UserCacheRefresher.cs index deb36ae894..eddefdaa98 100644 --- a/src/Umbraco.Web/Cache/UserCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/UserCacheRefresher.cs @@ -3,6 +3,7 @@ using Umbraco.Core; using Umbraco.Core.Cache; using Umbraco.Core.Models.Membership; using Umbraco.Core.Persistence.Caching; +using Umbraco.Core.Persistence.Repositories; using umbraco.interfaces; namespace Umbraco.Web.Cache @@ -29,9 +30,10 @@ namespace Umbraco.Web.Cache public override void RefreshAll() { - RuntimeCacheProvider.Current.Clear(typeof(IUser)); - ApplicationContext.Current.ApplicationCache.ClearCacheByKeySearch(CacheKeys.UserPermissionsCacheKey); - ApplicationContext.Current.ApplicationCache.ClearCacheByKeySearch(CacheKeys.UserContextCacheKey); + //RuntimeCacheProvider.Current.Clear(typeof(IUser)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch(CacheKeys.UserPermissionsCacheKey); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch(CacheKeys.UserContextCacheKey); base.RefreshAll(); } @@ -43,13 +45,14 @@ namespace Umbraco.Web.Cache public override void Remove(int id) { - RuntimeCacheProvider.Current.Delete(typeof (IUser), id); + //RuntimeCacheProvider.Current.Delete(typeof (IUser), id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(id)); - ApplicationContext.Current.ApplicationCache.ClearCacheItem(string.Format("{0}{1}", CacheKeys.UserPermissionsCacheKey, id)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(string.Format("{0}{1}", CacheKeys.UserPermissionsCacheKey, id)); //we need to clear all UserContextCacheKey since we cannot invalidate based on ID since the cache is done so based //on the current contextId stored in the database - ApplicationContext.Current.ApplicationCache.ClearCacheByKeySearch(CacheKeys.UserContextCacheKey); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch(CacheKeys.UserContextCacheKey); base.Remove(id); } diff --git a/src/Umbraco.Web/Cache/UserTypeCacheRefresher.cs b/src/Umbraco.Web/Cache/UserTypeCacheRefresher.cs index 1a726da815..22bbe7c216 100644 --- a/src/Umbraco.Web/Cache/UserTypeCacheRefresher.cs +++ b/src/Umbraco.Web/Cache/UserTypeCacheRefresher.cs @@ -3,6 +3,7 @@ using Umbraco.Core; using Umbraco.Core.Cache; using Umbraco.Core.Models.Membership; using Umbraco.Core.Persistence.Caching; +using Umbraco.Core.Persistence.Repositories; namespace Umbraco.Web.Cache { @@ -28,19 +29,22 @@ namespace Umbraco.Web.Cache public override void RefreshAll() { - RuntimeCacheProvider.Current.Clear(typeof (IUserType)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + //RuntimeCacheProvider.Current.Clear(typeof (IUserType)); base.RefreshAll(); } public override void Refresh(int id) { - RuntimeCacheProvider.Current.Delete(typeof(IUserType), id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(id)); + //RuntimeCacheProvider.Current.Delete(typeof(IUserType), id); base.Refresh(id); } public override void Remove(int id) { - RuntimeCacheProvider.Current.Delete(typeof(IUserType), id); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(RepositoryBase.GetCacheIdKey(id)); + //RuntimeCacheProvider.Current.Delete(typeof(IUserType), id); base.Remove(id); } diff --git a/src/umbraco.businesslogic/User.cs b/src/umbraco.businesslogic/User.cs index 798e4dc46c..3d0096da4b 100644 --- a/src/umbraco.businesslogic/User.cs +++ b/src/umbraco.businesslogic/User.cs @@ -4,10 +4,12 @@ using System.Web.Caching; using Umbraco.Core; using Umbraco.Core.Cache; using Umbraco.Core.Logging; +using Umbraco.Core.Models; using Umbraco.Core.Models.Membership; using Umbraco.Core.Models.Rdbms; using Umbraco.Core.Persistence.Caching; using Umbraco.Core.Persistence.Querying; +using Umbraco.Core.Persistence.Repositories; using umbraco.DataLayer; using System.Collections.Generic; using System.Linq; @@ -819,7 +821,8 @@ namespace umbraco.BusinessLogic public void FlushFromCache() { OnFlushingFromCache(EventArgs.Empty); - RuntimeCacheProvider.Current.Clear(typeof (IUser)); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + //RuntimeCacheProvider.Current.Clear(typeof (IUser)); } /// diff --git a/src/umbraco.cms/businesslogic/propertytype/propertytype.cs b/src/umbraco.cms/businesslogic/propertytype/propertytype.cs index df7cc04c38..4a2dc9e253 100644 --- a/src/umbraco.cms/businesslogic/propertytype/propertytype.cs +++ b/src/umbraco.cms/businesslogic/propertytype/propertytype.cs @@ -5,16 +5,17 @@ using System.Runtime.CompilerServices; using System.Threading; using Umbraco.Core; using Umbraco.Core.Cache; +using Umbraco.Core.Models; using Umbraco.Core.Persistence.Caching; using umbraco.BusinessLogic; using umbraco.cms.businesslogic.cache; -using umbraco.cms.businesslogic.datatype; -using umbraco.cms.businesslogic.language; using umbraco.cms.businesslogic.property; using umbraco.cms.businesslogic.web; using umbraco.cms.helpers; using umbraco.DataLayer; using umbraco.interfaces; +using DataTypeDefinition = umbraco.cms.businesslogic.datatype.DataTypeDefinition; +using Language = umbraco.cms.businesslogic.language.Language; namespace umbraco.cms.businesslogic.propertytype { @@ -465,7 +466,13 @@ namespace umbraco.cms.businesslogic.propertytype //Ensure that DocumentTypes are reloaded from db by clearing cache - this similar to the Save method on DocumentType. //NOTE Would be nice if we could clear cache by type instead of emptying the entire cache. InMemoryCacheProvider.Current.Clear(); - RuntimeCacheProvider.Current.Clear(); + //RuntimeCacheProvider.Current.Clear(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); } public static PropertyType GetPropertyType(int id) diff --git a/src/umbraco.cms/businesslogic/web/Document.cs b/src/umbraco.cms/businesslogic/web/Document.cs index 44d22945c5..a59039bea0 100644 --- a/src/umbraco.cms/businesslogic/web/Document.cs +++ b/src/umbraco.cms/businesslogic/web/Document.cs @@ -392,7 +392,8 @@ namespace umbraco.cms.businesslogic.web ApplicationContext.Current.DatabaseContext.Database.Execute( "update cmsDocument set templateId = NULL where templateId = @TemplateId", new {TemplateId = templateId}); //We need to clear cache for Documents since this is touching the database directly - RuntimeCacheProvider.Current.Clear(); + //RuntimeCacheProvider.Current.Clear(); + ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes(); } ///