swcs/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixes up dictionary and language repositories to have underlying simple get repositories since they support getting by id, unique id and string variations but we want to have native repository enabled caching for these items so these get methods now use private repositories based on these keys. Adds more tests, removes N+1 queries for languages and dictionary items. Removes RuntimeCacheProvider, we only want one type of cache, this simplifies things a lot.

Browse Source
This commit is contained in:
Shannon
2015-01-13 13:25:36 +11:00
parent ef2c46b6ab
commit e3acdbe85b
76 changed files with 1264 additions and 778 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Umbraco.Core/Persistence/Caching/RuntimeCacheProvider.cs
+213 -235
View File
@@ -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!
/// <summary>
/// The Runtime Cache provider looks up objects in the Runtime cache for fast retrival
/// </summary>
/// <remarks>
///
/// 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.
///
/// </remarks>
internal sealed class RuntimeCacheProvider : IRepositoryCacheProvider
{
#region Singleton
// /// <summary>
// /// The Runtime Cache provider looks up objects in the Runtime cache for fast retrival
// /// </summary>
// /// <remarks>
// ///
// /// 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.
// ///
// /// </remarks>
// internal sealed class RuntimeCacheProvider : IRepositoryCacheProvider
// {
// #region Singleton
private static readonly Lazy<RuntimeCacheProvider> lazy = new Lazy<RuntimeCacheProvider>(() => new RuntimeCacheProvider());
// private static readonly Lazy<RuntimeCacheProvider> lazy = new Lazy<RuntimeCacheProvider>(() => 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<string> _keyTracker = new ConcurrentHashSet<string>();
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<string> _keyTracker = new ConcurrentHashSet<string>();
// 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<IEntity> GetByIds(Type type, List<Guid> ids)
{
var collection = new List<IEntity>();
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<IEntity> GetByIds(Type type, List<Guid> ids)
// {
// var collection = new List<IEntity>();
// 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<IEntity> GetAllByType(Type type)
{
var collection = new List<IEntity>();
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<IEntity> GetAllByType(Type type)
// {
// var collection = new List<IEntity>();
// 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);
// }
// /// <summary>
// /// Clear cache by type
// /// </summary>
// /// <param name="type"></param>
// public void Clear(Type type)
// {
// using (new WriteLock(ClearLock))
// {
// var keys = new string[_keyTracker.Count];
// _keyTracker.CopyTo(keys, 0);
// var keysToRemove = new List<string>();
// 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();
// }
// }
/// <summary>
/// Clear cache by type
/// </summary>
/// <param name="type"></param>
public void Clear(Type type)
{
using (new WriteLock(ClearLock))
{
var keys = new string[_keyTracker.Count];
_keyTracker.CopyTo(keys, 0);
var keysToRemove = new List<string>();
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();
// /// <summary>
// /// 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.
// /// </summary>
// 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);
}
}
}
}
/// <summary>
/// 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.
/// </summary>
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());
}
}
}
// }
//}
src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs
+1 -1
View File
@@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories
internal class ContentPreviewRepository<TContent> : PetaPocoRepositoryBase<int, ContentPreviewEntity<TContent>>
where TContent : IContentBase
{
public ContentPreviewRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
public ContentPreviewRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
+9 -7
View File
@@ -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<IContent> _contentPreviewRepository;
private readonly ContentXmlRepository<IContent> _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<IContent>(work, NullCacheProvider.Current, logger);
_contentXmlRepository = new ContentXmlRepository<IContent>(work, NullCacheProvider.Current, logger);
_contentPreviewRepository = new ContentPreviewRepository<IContent>(work, CacheHelper.CreateDisabledCacheHelper(), logger);
_contentXmlRepository = new ContentXmlRepository<IContent>(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<IContent>(GetCacheIdKey<IContent>(dto.NodeId));
//var fromCache = TryGetFromCache(dto.NodeId);
if (fromCache != null && fromCache.Published)
{
yield return fromCache.Result;
yield return fromCache;
}
else
{
src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs
+2 -2
View File
@@ -27,8 +27,8 @@ namespace Umbraco.Core.Persistence.Repositories
internal abstract class ContentTypeBaseRepository<TEntity> : PetaPocoRepositoryBase<int, TEntity>
where TEntity : class, IContentTypeComposition
{
protected ContentTypeBaseRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
protected ContentTypeBaseRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
+1 -1
View File
@@ -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;
src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs
+1 -1
View File
@@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories
internal class ContentXmlRepository<TContent> : PetaPocoRepositoryBase<int, ContentXmlEntity<TContent>>
where TContent : IContentBase
{
public ContentXmlRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
public ContentXmlRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
+3 -3
View File
@@ -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",
/// </summary>
private class DataTypePreValueRepository : PetaPocoRepositoryBase<int, PreValueEntity>
{
public DataTypePreValueRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
public DataTypePreValueRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs
+141 -37
View File
@@ -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
/// </summary>
internal class DictionaryRepository : PetaPocoRepositoryBase<int, IDictionaryItem>, 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<int,DictionaryItem>
@@ -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<IDictionaryTranslation>();
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<IDictionaryItem> 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<DictionaryDto>("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<DictionaryDto, LanguageTextDto, DictionaryDto>(new DictionaryLanguageTextRelator().Map, sql)
.Select(ConvertFromDto);
}
protected override IEnumerable<IDictionaryItem> PerformGetByQuery(IQuery<IDictionaryItem> query)
@@ -85,12 +69,8 @@ namespace Umbraco.Core.Persistence.Repositories
var sql = translator.Translate();
sql.OrderBy<DictionaryDto>(x => x.UniqueId);
var dtos = Database.Fetch<DictionaryDto, LanguageTextDto, DictionaryDto>(new DictionaryLanguageTextRelator().Map, sql);
foreach (var dto in dtos)
{
yield return Get(dto.PrimaryKey);
}
return Database.Fetch<DictionaryDto, LanguageTextDto, DictionaryDto>(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<IDictionaryItem>(entity.ItemKey));
RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey<IDictionaryItem>(entity.Key));
}
protected override void PersistDeletedItem(IDictionaryItem entity)
@@ -196,8 +180,11 @@ namespace Umbraco.Core.Persistence.Repositories
RecursiveDelete(entity.Key);
Database.Delete<LanguageTextDto>("WHERE UniqueId = @Id", new { Id = entity.Key});
Database.Delete<DictionaryDto>("WHERE id = @Id", new { Id = entity.Key });
//Clear the cache entries that exist by uniqueid/item key
RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey<IDictionaryItem>(entity.ItemKey));
RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey<IDictionaryItem>(entity.Key));
}
private void RecursiveDelete(Guid parentId)
@@ -209,9 +196,126 @@ namespace Umbraco.Core.Persistence.Repositories
Database.Delete<LanguageTextDto>("WHERE UniqueId = @Id", new { Id = dto.UniqueId });
Database.Delete<DictionaryDto>("WHERE id = @Id", new { Id = dto.UniqueId });
//Clear the cache entries that exist by uniqueid/item key
RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey<IDictionaryItem>(dto.Key));
RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey<IDictionaryItem>(dto.UniqueId));
}
}
#endregion
protected IDictionaryItem ConvertFromDto(DictionaryDto dto)
{
var factory = new DictionaryItemFactory();
var entity = factory.BuildEntity(dto);
var list = new List<IDictionaryTranslation>();
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<Guid, IDictionaryItem, DictionaryDto>
{
private readonly DictionaryRepository _dictionaryRepository;
public DictionaryByUniqueIdRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
_dictionaryRepository = dictionaryRepository;
}
protected override IEnumerable<DictionaryDto> PerformFetch(Sql sql)
{
return Database.Fetch<DictionaryDto, LanguageTextDto, DictionaryDto>(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<string, IDictionaryItem, DictionaryDto>
{
private readonly DictionaryRepository _dictionaryRepository;
public DictionaryByKeyRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
_dictionaryRepository = dictionaryRepository;
}
protected override IEnumerable<DictionaryDto> PerformFetch(Sql sql)
{
return Database.Fetch<DictionaryDto, LanguageTextDto, DictionaryDto>(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)";
}
}
}
}
src/Umbraco.Core/Persistence/Repositories/Interfaces/IDictionaryRepository.cs
+4 -2
View File
@@ -1,9 +1,11 @@
using Umbraco.Core.Models;
using System;
using Umbraco.Core.Models;
namespace Umbraco.Core.Persistence.Repositories
{
public interface IDictionaryRepository : IRepositoryQueryable<int, IDictionaryItem>
{
IDictionaryItem Get(Guid uniqueId);
IDictionaryItem Get(string key);
}
}
src/Umbraco.Core/Persistence/Repositories/Interfaces/ILanguageRepository.cs
+2 -1
View File
@@ -4,6 +4,7 @@ namespace Umbraco.Core.Persistence.Repositories
{
public interface ILanguageRepository : IRepositoryQueryable<int, ILanguage>
{
ILanguage GetByCultureName(string cultureName);
ILanguage GetByIsoCode(string isoCode);
}
}
src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs
+117 -27
View File
@@ -17,7 +17,7 @@ namespace Umbraco.Core.Persistence.Repositories
/// </summary>
internal class LanguageRepository : PetaPocoRepositoryBase<int, ILanguage>, 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<ILanguage> 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<LanguageDto>("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<LanguageDto>(sql).Select(ConvertFromDto);
}
protected override IEnumerable<ILanguage> PerformGetByQuery(IQuery<ILanguage> query)
{
var sqlClause = GetBaseQuery(false);
var translator = new SqlTranslator<ILanguage>(sqlClause, query);
var sql = translator.Translate();
var dtos = Database.Fetch<LanguageDto>(sql);
foreach (var dto in dtos)
{
yield return Get(dto.Id);
}
return Database.Fetch<LanguageDto>(sql).Select(ConvertFromDto);
}
#endregion
@@ -99,7 +80,7 @@ namespace Umbraco.Core.Persistence.Repositories
protected override IEnumerable<string> GetDeleteClauses()
{
var list = new List<string>
{
//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<ILanguage>(entity.IsoCode));
RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey<ILanguage>(entity.CultureName));
}
protected override void PersistDeletedItem(ILanguage entity)
{
base.PersistDeletedItem(entity);
//Clear the cache entries that exist by key/iso
RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey<ILanguage>(entity.IsoCode));
RepositoryCache.RuntimeCache.ClearCacheItem(GetCacheIdKey<ILanguage>(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);
}
/// <summary>
/// Inner repository for looking up languages by ISO code, this deals with caching by a string key
/// </summary>
private class LanguageByIsoCodeRepository : SimpleGetRepository<string, ILanguage, LanguageDto>
{
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<string, ILanguage, LanguageDto>
{
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)";
}
}
}
}
src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs
+2 -2
View File
@@ -16,8 +16,8 @@ namespace Umbraco.Core.Persistence.Repositories
{
internal class MacroRepository : PetaPocoRepositoryBase<int, IMacro>, IMacroRepository
{
public MacroRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
public MacroRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs
+3 -3
View File
@@ -31,15 +31,15 @@ namespace Umbraco.Core.Persistence.Repositories
private readonly ContentXmlRepository<IMedia> _contentXmlRepository;
private readonly ContentPreviewRepository<IMedia> _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<IMedia>(work, NullCacheProvider.Current, logger);
_contentPreviewRepository = new ContentPreviewRepository<IMedia>(work, NullCacheProvider.Current, logger);
_contentXmlRepository = new ContentXmlRepository<IMedia>(work, CacheHelper.CreateDisabledCacheHelper(), logger);
_contentPreviewRepository = new ContentPreviewRepository<IMedia>(work, CacheHelper.CreateDisabledCacheHelper(), logger);
EnsureUniqueNaming = true;
}
src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
+2 -2
View File
@@ -17,8 +17,8 @@ namespace Umbraco.Core.Persistence.Repositories
/// </summary>
internal class MediaTypeRepository : ContentTypeBaseRepository<IMediaType>, IMediaTypeRepository
{
public MediaTypeRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
public MediaTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs
+2 -2
View File
@@ -21,8 +21,8 @@ namespace Umbraco.Core.Persistence.Repositories
internal class MemberGroupRepository : PetaPocoRepositoryBase<int, IMemberGroup>, 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");
src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs
+3 -3
View File
@@ -33,7 +33,7 @@ namespace Umbraco.Core.Persistence.Repositories
private readonly ContentXmlRepository<IMember> _contentXmlRepository;
private readonly ContentPreviewRepository<IMember> _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<IMember>(work, NullCacheProvider.Current, logger);
_contentPreviewRepository = new ContentPreviewRepository<IMember>(work, NullCacheProvider.Current, logger);
_contentXmlRepository = new ContentXmlRepository<IMember>(work, CacheHelper.CreateDisabledCacheHelper(), logger);
_contentPreviewRepository = new ContentPreviewRepository<IMember>(work, CacheHelper.CreateDisabledCacheHelper(), logger);
}
#region Overrides of RepositoryBase<int, IMembershipUser>
src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs
+1 -1
View File
@@ -20,7 +20,7 @@ namespace Umbraco.Core.Persistence.Repositories
internal class MemberTypeRepository : ContentTypeBaseRepository<IMemberType>, IMemberTypeRepository
{
public MemberTypeRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
public MemberTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/PetaPocoRepositoryBase.cs
+1 -1
View File
@@ -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)
{
}
src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs
+1 -1
View File
@@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories
internal abstract class RecycleBinRepository<TId, TEntity> : VersionableRepositoryBase<TId, TEntity>, IRecycleBinRepository<TEntity>
where TEntity : class, IUmbracoEntity
{
protected RecycleBinRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
protected RecycleBinRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs
+3 -1
View File
@@ -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<IRelation> PerformGetAll(params int[] ids)
{
if (ids.Any())
src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs
+1 -1
View File
@@ -18,7 +18,7 @@ namespace Umbraco.Core.Persistence.Repositories
internal class RelationTypeRepository : PetaPocoRepositoryBase<int, IRelationType>, IRelationTypeRepository
{
public RelationTypeRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
public RelationTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/RepositoryBase.cs
+115 -84
View File
@@ -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
{
/// <summary>
/// Represent an abstract Repository, which is the base of the Repository implementations
/// </summary>
/// <typeparam name="TEntity">Type of <see cref="IAggregateRoot"/> entity for which the repository is used</typeparam>
/// <typeparam name="TId">Type of the Id used for this entity</typeparam>
internal abstract class RepositoryBase<TId, TEntity> : DisposableObject, IRepositoryQueryable<TId, TEntity>, 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<T>(object id)
{
return string.Format("{0}{1}", GetCacheTypeKey<T>(), id);
}
public static string GetCacheTypeKey<T>()
{
return string.Format("uRepo_{0}_", typeof(T).Name);
}
protected ILogger Logger { get; private set; }
}
/// <summary>
/// Represent an abstract Repository, which is the base of the Repository implementations
/// </summary>
/// <typeparam name="TEntity">Type of <see cref="IAggregateRoot"/> entity for which the repository is used</typeparam>
/// <typeparam name="TId">Type of the Id used for this entity</typeparam>
internal abstract class RepositoryBase<TId, TEntity> : RepositoryBase, IRepositoryQueryable<TId, TEntity>, IUnitOfWorkRepository
where TEntity : class, IAggregateRoot
{
protected RepositoryBase(IUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
#region IRepository<TEntity> Members
/// <summary>
@@ -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
/// <param name="entity"></param>
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
/// <returns></returns>
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<TEntity>(
GetCacheIdKey<TEntity>(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<TEntity> 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<TEntity>.Fail();
}
//protected Attempt<TEntity> 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<TEntity>.Fail();
//}
protected abstract IEnumerable<TEntity> PerformGetAll(params TId[] ids);
/// <summary>
@@ -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<TEntity>(GetCacheIdKey<TEntity>(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<TEntity>(GetCacheTypeKey<TEntity>()).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<TEntity>(entity.Id), () => localCopy);
//RepositoryCache.Save(typeof(TEntity), entity);
}
}
@@ -211,11 +232,16 @@ namespace Umbraco.Core.Persistence.Repositories
/// <returns></returns>
public bool Exists(TId id)
{
var fromCache = TryGetFromCache(id);
if (fromCache.Success)
var fromCache = RepositoryCache.RuntimeCache.GetCacheItem<TEntity>(GetCacheIdKey<TEntity>(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<TEntity>(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<TEntity>(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<TEntity>(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<TEntity>(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<TEntity>(entity.Id));
}
#endregion
@@ -296,29 +327,29 @@ namespace Umbraco.Core.Persistence.Repositories
#endregion
/// <summary>
/// Internal method that handles the convertion of an object Id
/// to an Integer and then a Guid Id.
/// </summary>
/// <remarks>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.</remarks>
/// <param name="id"></param>
/// <returns></returns>
protected virtual Guid ConvertIdToGuid(TId id)
{
int i = 0;
if (int.TryParse(id.ToString(), out i))
{
return i.ToGuid();
}
return ConvertStringIdToGuid(id.ToString());
}
///// <summary>
///// Internal method that handles the convertion of an object Id
///// to an Integer and then a Guid Id.
///// </summary>
///// <remarks>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.</remarks>
///// <param name="id"></param>
///// <returns></returns>
//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();
//}
/// <summary>
/// Dispose disposable properties
src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs
+1 -1
View File
@@ -14,7 +14,7 @@ namespace Umbraco.Core.Persistence.Repositories
{
internal class ServerRegistrationRepository : PetaPocoRepositoryBase<int, ServerRegistration>
{
public ServerRegistrationRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
public ServerRegistrationRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs
+99
View File
@@ -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
{
/// <summary>
/// Simple abstract ReadOnly repository used to simply have PerformGet and PeformGetAll with an underlying cache
/// </summary>
internal abstract class SimpleGetRepository<TId, TEntity, TDto> : PetaPocoRepositoryBase<TId, TEntity>
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<TDto> PerformFetch(Sql sql)
{
return Database.Fetch<TDto>(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<TEntity> PerformGetAll(params TId[] ids)
{
var sql = new Sql().From<TEntity>();
if (ids.Any())
{
sql.Where(GetWhereInClauseForGetAll(), new { ids = ids });
}
return Database.Fetch<TDto>(sql).Select(ConvertToEntity);
}
protected override sealed IEnumerable<TEntity> PerformGetByQuery(IQuery<TEntity> query)
{
var sqlClause = GetBaseQuery(false);
var translator = new SqlTranslator<TEntity>(sqlClause, query);
var sql = translator.Translate();
return Database.Fetch<TDto>(sql).Select(ConvertToEntity);
}
#region Not implemented and not required
protected override sealed IEnumerable<string> 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
}
}
src/Umbraco.Core/Persistence/Repositories/TagRepository.cs
+1 -1
View File
@@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories
{
internal class TagRepository : PetaPocoRepositoryBase<int, ITag>, ITagRepository
{
internal TagRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
internal TagRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
+1 -1
View File
@@ -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;
src/Umbraco.Core/Persistence/Repositories/UserRepository.cs
+1 -1
View File
@@ -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;
src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs
+1 -1
View File
@@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.Repositories
/// </summary>
internal class UserTypeRepository : PetaPocoRepositoryBase<int, IUserType>, IUserTypeRepository
{
public UserTypeRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
public UserTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs
+2 -2
View File
@@ -22,8 +22,8 @@ namespace Umbraco.Core.Persistence.Repositories
internal abstract class VersionableRepositoryBase<TId, TEntity> : PetaPocoRepositoryBase<TId, TEntity>
where TEntity : class, IAggregateRoot
{
protected VersionableRepositoryBase(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, ILogger logger)
protected VersionableRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger)
: base(work, cache, logger)
{
}
src/Umbraco.Core/Persistence/RepositoryFactory.cs
+36 -46
View File
@@ -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
/// </summary>
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);
}
src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProvidersResolver.cs
+1
View File
@@ -8,6 +8,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
/// <summary>
/// A resolver to return all ISqlSyntaxProvider objects
/// </summary>
[Obsolete("This should really not be used, instead ISqlSyntaxProvider should be ctor injected into any service that needs it")]
internal sealed class SqlSyntaxProvidersResolver : ManyObjectsResolverBase<SqlSyntaxProvidersResolver, ISqlSyntaxProvider>
{
/// <summary>
src/Umbraco.Core/Services/ContentService.cs
+5 -5
View File
@@ -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;
}
src/Umbraco.Core/Services/LocalizationService.cs
+23 -17
View File
@@ -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<IDictionaryItem>.Builder.Where(x => x.Key == id);
var items = repository.GetByQuery(query);
return repository.Get(id);
//var query = Query<IDictionaryItem>.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<IDictionaryItem>.Builder.Where(x => x.ItemKey == key);
var items = repository.GetByQuery(query);
return repository.Get(key);
//var query = Query<IDictionaryItem>.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<IDictionaryItem>.Builder.Where(x => x.ItemKey == key);
var items = repository.GetByQuery(query);
return repository.Get(key) != null;
//var query = Query<IDictionaryItem>.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<ILanguage>.Builder.Where(x => x.CultureName == cultureName);
var items = repository.GetByQuery(query);
return repository.GetByCultureName(cultureName);
//var query = Query<ILanguage>.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<ILanguage>.Builder.Where(x => x.IsoCode == isoCode);
var items = repository.GetByQuery(query);
return repository.GetByIsoCode(isoCode);
//var query = Query<ILanguage>.Builder.Where(x => x.IsoCode == isoCode);
//var items = repository.GetByQuery(query);
return items.FirstOrDefault();
//return items.FirstOrDefault();
}
}
src/Umbraco.Core/Umbraco.Core.csproj
+1
View File
@@ -321,6 +321,7 @@
<Compile Include="Logging\LoggerResolver.cs" />
<Compile Include="Models\IPartialView.cs" />
<Compile Include="Persistence\DatabaseSchemaHelper.cs" />
<Compile Include="Persistence\Repositories\SimpleGetRepository.cs" />
<Compile Include="Services\LocalizedTextService.cs" />
<Compile Include="Services\ILocalizedTextService.cs" />
<Compile Include="Logging\ILogger.cs" />
src/Umbraco.Tests/Migrations/Upgrades/ValidateV7TagsUpgradeTest.cs
+4 -4
View File
@@ -25,10 +25,10 @@ namespace Umbraco.Tests.Migrations.Upgrades
{
private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository)
{
var templateRepository = new TemplateRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var tagRepository = new TagRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>());
contentTypeRepository = new ContentTypeRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), templateRepository);
var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), templateRepository);
var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
return repository;
}
src/Umbraco.Tests/MockTests.cs
+5 -4
View File
@@ -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<IFileService>().Object,
new Mock<ILocalizationService>().Object,
new Mock<IUserService>().Object,
new RepositoryFactory(true, Mock.Of<ILogger>(), Mock.Of<IUmbracoSettingsSection>()),
new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<ISqlSyntaxProvider>(), Mock.Of<IUmbracoSettingsSection>()),
new Mock<IDatabaseUnitOfWorkProvider>().Object),
new Mock<IEntityService>().Object,
new RelationService(
new Mock<IDatabaseUnitOfWorkProvider>().Object,
new RepositoryFactory(true, Mock.Of<ILogger>(), Mock.Of<IUmbracoSettingsSection>()),
new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<ISqlSyntaxProvider>(), Mock.Of<IUmbracoSettingsSection>()),
new Mock<IEntityService>().Object),
new Mock<IMemberGroupService>().Object,
new Mock<IMemberTypeService>().Object,
@@ -94,12 +95,12 @@ namespace Umbraco.Tests
new Mock<IFileService>().Object,
new Mock<ILocalizationService>().Object,
new Mock<IUserService>().Object,
new RepositoryFactory(true, Mock.Of<ILogger>(), Mock.Of<IUmbracoSettingsSection>()),
new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<ISqlSyntaxProvider>(), Mock.Of<IUmbracoSettingsSection>()),
new Mock<IDatabaseUnitOfWorkProvider>().Object),
new Mock<IEntityService>().Object,
new RelationService(
new Mock<IDatabaseUnitOfWorkProvider>().Object,
new RepositoryFactory(true, Mock.Of<ILogger>(), Mock.Of<IUmbracoSettingsSection>()),
new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<ISqlSyntaxProvider>(), Mock.Of<IUmbracoSettingsSection>()),
new Mock<IEntityService>().Object),
new Mock<IMemberGroupService>().Object,
new Mock<IMemberTypeService>().Object,
src/Umbraco.Tests/Models/ContentTests.cs
+5 -3
View File
@@ -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<ContentTests>("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));
}
}
src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs
+3 -2
View File
@@ -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<IUmbracoSettingsSection>()));
//disable cache
src/Umbraco.Tests/Persistence/Caching/RuntimeCacheProviderTest.cs
+113 -113
View File
@@ -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<Guid> { mockedEntity1.Key, mockedEntity2.Key }).ToList();
// // Act
// var entities = _registry.GetByIds(typeof(MockedEntity), new List<Guid> { 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));
}
}
}
// // Assert
// Assert.That(countBefore, Is.GreaterThan(countAfter));
// Assert.That(entitiesAfterDeletion.Count(x => x.Id == mockedEntity.Id), Is.EqualTo(0));
// }
// }
//}
src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs
+4 -4
View File
@@ -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<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var tagRepository = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>());
contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), templateRepository);
var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), templateRepository);
var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
return repository;
}
src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs
+7 -7
View File
@@ -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<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var tagRepository = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>());
contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), templateRepository);
var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), templateRepository);
var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
return repository;
}
private ContentTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
{
var templateRepository = new TemplateRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var contentTypeRepository = new ContentTypeRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), templateRepository);
var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), 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<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>()))
using (var templateRepo = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>()))
using (var repository = CreateRepository(unitOfWork))
{
var templates = new[]
src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs
+9 -9
View File
@@ -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<ILogger>(),
new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(),
new TemplateRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>())));
new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(),
new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>())));
return dataTypeDefinitionRepository;
}
@@ -375,11 +375,11 @@ namespace Umbraco.Tests.Persistence.Repositories
var cache = new CacheHelper(new ObjectCacheRuntimeCacheProvider(), new StaticCacheProvider(), new StaticCacheProvider());
Func<DataTypeDefinitionRepository> creator = () => new DataTypeDefinitionRepository(
unitOfWork, NullCacheProvider.Current,
unitOfWork, CacheHelper.CreateDisabledCacheHelper(),
cache,
Mock.Of<ILogger>(),
new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(),
new TemplateRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>())));
new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(),
new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>())));
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<DataTypeDefinitionRepository> creator = () => new DataTypeDefinitionRepository(
unitOfWork, NullCacheProvider.Current,
unitOfWork, CacheHelper.CreateDisabledCacheHelper(),
cache,
Mock.Of<ILogger>(),
new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(),
new TemplateRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>())));
new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(),
new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>())));
DataTypeDefinition dtd;
using (var repository = creator())
src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs
+72 -4
View File
@@ -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<ILogger>());
var dictionaryRepository = new DictionaryRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), languageRepository);
languageRepository = new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var dictionaryRepository = new DictionaryRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), 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<IDictionaryTranslation>
{
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<IDictionaryTranslation>
{
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<IRepositoryCacheProvider>(), Mock.Of<ILogger>());
var repository = new DictionaryRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), languageRepository);
var languageRepository = new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var repository = new DictionaryRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), new SqlCeSyntaxProvider(), languageRepository);
var languageNo = new Language("nb-NO") { CultureName = "nb-NO" };
ServiceContext.LocalizationService.Save(languageNo);
src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs
+56 -2
View File
@@ -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<ILogger>());
return new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
}
[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()
{
src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs
+19 -18
View File
@@ -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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
// 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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
// 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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
// 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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
// Act
var query = Query<IMacro>.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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
// Act
var query = Query<IMacro>.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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
// 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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
// 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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
// 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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
// 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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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<IRepositoryCacheProvider>(), Mock.Of<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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"));
src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs
+3 -3
View File
@@ -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<ILogger>());
var tagRepository = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>());
var repository = new MediaRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), mediaTypeRepository, tagRepository);
mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var repository = new MediaRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), mediaTypeRepository, tagRepository);
return repository;
}
src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs
+1 -1
View File
@@ -27,7 +27,7 @@ namespace Umbraco.Tests.Persistence.Repositories
private MediaTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
{
return new MediaTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>());
return new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
}
[Test]
src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs
+4 -4
View File
@@ -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<ILogger>());
memberGroupRepository = new MemberGroupRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), CacheHelper.CreateDisabledCacheHelper());
var tagRepo = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>());
var repository = new MemberRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), memberTypeRepository, memberGroupRepository, tagRepo);
memberTypeRepository = new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
memberGroupRepository = new MemberGroupRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), CacheHelper.CreateDisabledCacheHelper());
var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var repository = new MemberRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), memberTypeRepository, memberGroupRepository, tagRepo);
return repository;
}
src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs
+1 -1
View File
@@ -32,7 +32,7 @@ namespace Umbraco.Tests.Persistence.Repositories
private MemberTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
{
return new MemberTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>());
return new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
}
[Test]
src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs
+4 -4
View File
@@ -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<ILogger>());
var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), relationTypeRepository);
relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var repository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), 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<ILogger>());
var relationRepository = new RelationRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), relationTypeRepository);
var relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var relationRepository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), relationTypeRepository);
relationTypeRepository.AddOrUpdate(relateContent);
relationTypeRepository.AddOrUpdate(relateContentType);
src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs
+2 -2
View File
@@ -29,7 +29,7 @@ namespace Umbraco.Tests.Persistence.Repositories
private RelationTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
{
return new RelationTypeRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>());
return new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
}
[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<IRepositoryCacheProvider>(), Mock.Of<ILogger>());
var repository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
repository.AddOrUpdate(relateContent);//Id 2
repository.AddOrUpdate(relateContentType);//Id 3
src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs
+3 -2
View File
@@ -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<IRepositoryCacheProvider>(), Mock.Of<ILogger>());
return new ServerRegistrationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
}
[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<IRepositoryCacheProvider>(), Mock.Of<ILogger>()))
using (var repository = new ServerRegistrationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
repository.AddOrUpdate(new ServerRegistration("http://localhost", "COMPUTER1", DateTime.Now) { IsActive = true });
repository.AddOrUpdate(new ServerRegistration("http://www.mydomain.com", "COMPUTER2", DateTime.Now));
src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs
+8 -8
View File
@@ -35,7 +35,7 @@ namespace Umbraco.Tests.Persistence.Repositories
private TagRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
{
var tagRepository = new TagRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>());
var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
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<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var tagRepository = new TagRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>());
contentTypeRepository = new ContentTypeRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), templateRepository);
var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>());
var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), templateRepository);
var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
return repository;
}
private MediaRepository CreateMediaRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository)
{
var tagRepository = new TagRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>());
mediaTypeRepository = new MediaTypeRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>());
var repository = new MediaRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), mediaTypeRepository, tagRepository);
var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var repository = new MediaRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), mediaTypeRepository, tagRepository);
return repository;
}
}
src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs
+21 -21
View File
@@ -60,7 +60,7 @@ namespace Umbraco.Tests.Persistence.Repositories
var unitOfWork = provider.GetUnitOfWork();
// Act
using (var repository = new TemplateRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)))
{
var template = new Template("test", "test", _viewsFileSystem, _masterPageFileSystem, Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)))
{
var template = new Template("test", "test", _viewsFileSystem, _masterPageFileSystem, Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)))
{
var tagRepository = new TagRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>());
var contentTypeRepository = new ContentTypeRepository(unitOfWork, Mock.Of<IRepositoryCacheProvider>(), Mock.Of<ILogger>(), templateRepository);
var contentRepo = new ContentRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), templateRepository);
var contentRepo = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), 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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)))
{
var parent = new Template("parent", "parent", _viewsFileSystem, _masterPageFileSystem, Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)))
{
var parent = new Template("parent", "parent", _viewsFileSystem, _masterPageFileSystem, Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)))
{
var parent = new Template("parent", "parent", _viewsFileSystem, _masterPageFileSystem, Mock.Of<ITemplatesSection>(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<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
using (var repository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), _masterPageFileSystem, _viewsFileSystem,
Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc)))
{
var parent = new Template("parent", "parent", _viewsFileSystem, _masterPageFileSystem, Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc));
src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs
+2 -2
View File
@@ -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<ILogger>());
var repository = new UserRepository(unitOfWork, NullCacheProvider.Current, Mock.Of<ILogger>(), userTypeRepository, CacheHelper.CreateDisabledCacheHelper());
userTypeRepository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), userTypeRepository, CacheHelper.CreateDisabledCacheHelper());
return repository;
}
src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs
+2 -1
View File
@@ -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<IRepositoryCacheProvider>(), Mock.Of<ILogger>());
return new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
}
[Test]
src/Umbraco.Tests/Persistence/RepositoryResolverTests.cs
+3 -1
View File
@@ -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<ILogger>(),
new SqlCeSyntaxProvider(),
SettingsForTests.GenerateMockSettings()));
Resolution.Freeze();
src/Umbraco.Tests/Services/MacroServiceTests.cs
+2 -1
View File
@@ -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<IRepositoryCacheProvider>(), Mock.Of<ILogger>()))
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>()))
{
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"));
src/Umbraco.Tests/Services/PerformanceTests.cs
+1 -8
View File
@@ -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<IContent>();
//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));
src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs
+2 -1
View File
@@ -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(
src/Umbraco.Tests/TestHelpers/BaseDatabaseTest.cs
+2 -1
View File
@@ -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<IUmbracoSettingsSection>()));
SqlSyntaxProvidersResolver.Current = new SqlSyntaxProvidersResolver(
src/Umbraco.Web/Cache/ContentTypeCacheRefresher.cs
+10 -8
View File
@@ -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<IContent>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IContentType>();
//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<IContent>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IContentType>();
}
if (payloads.Any(x => x.Type == typeof(IMediaType).Name))
{
RuntimeCacheProvider.Current.Clear(typeof(IMedia));
RuntimeCacheProvider.Current.Clear(typeof(IMediaType));
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMedia>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMediaType>();
}
if (payloads.Any(x => x.Type == typeof(IMemberType).Name))
{
RuntimeCacheProvider.Current.Clear(typeof(IMember));
RuntimeCacheProvider.Current.Clear(typeof(IMemberType));
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMember>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMemberType>();
}
src/Umbraco.Web/Cache/DataTypeCacheRefresher.cs
+13 -6
View File
@@ -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<IContent>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IContentType>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMedia>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMediaType>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMember>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMemberType>();
payloads.ForEach(payload =>
{
src/Umbraco.Web/Cache/DictionaryCacheRefresher.cs
+5 -2
View File
@@ -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<IDictionaryItem>();
//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<IDictionaryItem>();
//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();
src/Umbraco.Web/Cache/LanguageCacheRefresher.cs
+4 -2
View File
@@ -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<ILanguage>();
base.Refresh(id);
}
public override void Remove(int id)
{
RuntimeCacheProvider.Current.Clear(typeof(ILanguage));
//RuntimeCacheProvider.Current.Clear(typeof(ILanguage));
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<ILanguage>();
//when a language is removed we must also clear the text cache!
//global::umbraco.cms.businesslogic.language.Item.ClearCache();
base.Remove(id);
src/Umbraco.Web/Cache/MacroCacheRefresher.cs
+8 -5
View File
@@ -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<MacroCacheContent>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<MacroCacheContent>();
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<IMacro>();
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<IMacro>(payload.Id));
});
base.Refresh(jsonPayload);
src/Umbraco.Web/Cache/MediaCacheRefresher.cs
+7 -4
View File
@@ -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<IMedia>(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));
}
src/Umbraco.Web/Cache/MemberCacheRefresher.cs
+6 -3
View File
@@ -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<IMember>(id));
//RuntimeCacheProvider.Current.Delete(typeof(IMember), id);
}
}
}
src/Umbraco.Web/Cache/MemberGroupCacheRefresher.cs
+3 -1
View File
@@ -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<IMemberGroup>(payload.Id));
}
});
src/Umbraco.Web/Cache/TemplateCacheRefresher.cs
+4 -3
View File
@@ -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<ITemplate>();
}
}
src/Umbraco.Web/Cache/UnpublishedPageCacheRefresher.cs
+14 -6
View File
@@ -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<IContent>();
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<IContent>(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<IContent>(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<IContent>(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<IContent>(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<IContent>(payload.Id));
content.Instance.UpdateSortOrder(payload.Id);
}
src/Umbraco.Web/Cache/UserCacheRefresher.cs
+9 -6
View File
@@ -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<IUser>();
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<IUser>(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);
}
src/Umbraco.Web/Cache/UserTypeCacheRefresher.cs
+7 -3
View File
@@ -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<IUserType>();
//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<IUserType>(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<IUserType>(id));
//RuntimeCacheProvider.Current.Delete(typeof(IUserType), id);
base.Remove(id);
}
src/umbraco.businesslogic/User.cs
+4 -1
View File
@@ -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<IUser>();
//RuntimeCacheProvider.Current.Clear(typeof (IUser));
}
/// <summary>
src/umbraco.cms/businesslogic/propertytype/propertytype.cs
+10 -3
View File
@@ -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<IContent>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IContentType>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMedia>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMediaType>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMember>();
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheObjectTypes<IMemberType>();
}
public static PropertyType GetPropertyType(int id)
src/umbraco.cms/businesslogic/web/Document.cs
+2 -1
View File
@@ -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<IContent>();
}
/// <summary>