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

Removed references from web and Models builder.. Moved some classes to do so

Browse Source
This commit is contained in:
Bjarke Berg
2020-02-06 14:09:16 +01:00
parent 41fde9318d
commit a018315404
10 changed files with 20 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/Umbraco.Abstractions/PublishedCache/DefaultCultureAccessor.cs Normal file
View File

@@ -0,0 +1,28 @@
using Umbraco.Core;
using Umbraco.Core.Services;
namespace Umbraco.Web.PublishedCache
{
/// <summary>
/// Provides the default implementation of <see cref="IDefaultCultureAccessor"/>.
/// </summary>
public class DefaultCultureAccessor : IDefaultCultureAccessor
{
private readonly ILocalizationService _localizationService;
private readonly RuntimeLevel _runtimeLevel;
/// <summary>
/// Initializes a new instance of the <see cref="DefaultCultureAccessor"/> class.
/// </summary>
public DefaultCultureAccessor(ILocalizationService localizationService, IRuntimeState runtimeState)
{
_localizationService = localizationService;
_runtimeLevel = runtimeState.Level;
}
/// <inheritdoc />
public string DefaultCulture => _runtimeLevel == RuntimeLevel.Run
? _localizationService.GetDefaultLanguageIsoCode() ?? "" // fast
: "en-US"; // default for install and upgrade, when the service is n/a
}
}

7
src/Umbraco.Abstractions/PublishedCache/IPublishedElementFactory.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace Umbraco.Web.PublishedCache
{
public interface IPublishedElementFactory
{
}
}

88
src/Umbraco.Abstractions/PublishedCache/PublishedElement.cs Normal file
View File

@@ -0,0 +1,88 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Umbraco.Core.Models.PublishedContent;
using Umbraco.Core.PropertyEditors;
namespace Umbraco.Web.PublishedCache
{
// notes:
// a published element does NOT manage any tree-like elements, neither the
// original NestedContent (from Lee) nor the DetachedPublishedContent POC did.
//
// at the moment we do NOT support models for sets - that would require
// an entirely new models factory + not even sure it makes sense at all since
// sets are created manually todo yes it does! - what does this all mean?
//
public class PublishedElement : IPublishedElement
{
// initializes a new instance of the PublishedElement class
// within the context of a published snapshot service (eg a published content property value)
public PublishedElement(IPublishedContentType contentType, Guid key, Dictionary<string, object> values, bool previewing,
PropertyCacheLevel referenceCacheLevel, IPublishedSnapshotAccessor publishedSnapshotAccessor)
{
if (key == Guid.Empty) throw new ArgumentException("Empty guid.");
if (values == null) throw new ArgumentNullException(nameof(values));
if (referenceCacheLevel != PropertyCacheLevel.None && publishedSnapshotAccessor == null)
throw new ArgumentNullException("A published snapshot accessor is required when referenceCacheLevel != None.", nameof(publishedSnapshotAccessor));
ContentType = contentType ?? throw new ArgumentNullException(nameof(contentType));
Key = key;
values = GetCaseInsensitiveValueDictionary(values);
_propertiesArray = contentType
.PropertyTypes
.Select(propertyType =>
{
values.TryGetValue(propertyType.Alias, out var value);
return (IPublishedProperty) new PublishedElementPropertyBase(propertyType, this, previewing, referenceCacheLevel, value, publishedSnapshotAccessor);
})
.ToArray();
}
// initializes a new instance of the PublishedElement class
// without any context, so it's purely 'standalone' and should NOT interfere with the published snapshot service
// + using an initial reference cache level of .None ensures that everything will be
// cached at .Content level - and that reference cache level will propagate to all
// properties
public PublishedElement(IPublishedContentType contentType, Guid key, Dictionary<string, object> values, bool previewing)
: this(contentType, key, values, previewing, PropertyCacheLevel.None, null)
{ }
private static Dictionary<string, object> GetCaseInsensitiveValueDictionary(Dictionary<string, object> values)
{
// ensure we ignore case for property aliases
var comparer = values.Comparer;
var ignoreCase = Equals(comparer, StringComparer.OrdinalIgnoreCase) || Equals(comparer, StringComparer.InvariantCultureIgnoreCase) || Equals(comparer, StringComparer.CurrentCultureIgnoreCase);
return ignoreCase ? values : new Dictionary<string, object>(values, StringComparer.OrdinalIgnoreCase);
}
#region ContentType
public IPublishedContentType ContentType { get; }
#endregion
#region PublishedElement
public Guid Key { get; }
#endregion
#region Properties
private readonly IPublishedProperty[] _propertiesArray;
public IEnumerable<IPublishedProperty> Properties => _propertiesArray;
public IPublishedProperty GetProperty(string alias)
{
var index = ContentType.GetPropertyIndex(alias);
var property = index < 0 ? null : _propertiesArray[index];
return property;
}
#endregion
}
}

190
src/Umbraco.Abstractions/PublishedCache/PublishedElementPropertyBase.cs Normal file
View File

@@ -0,0 +1,190 @@
using System;
using Umbraco.Core.Cache;
using Umbraco.Core.Models.PublishedContent;
using Umbraco.Core.PropertyEditors;
namespace Umbraco.Web.PublishedCache
{
internal class PublishedElementPropertyBase : PublishedPropertyBase
{
private readonly object _locko = new object();
private readonly object _sourceValue;
private readonly IPublishedSnapshotAccessor _publishedSnapshotAccessor;
protected readonly IPublishedElement Element;
protected readonly bool IsPreviewing;
protected readonly bool IsMember;
private bool _interInitialized;
private object _interValue;
private CacheValues _cacheValues;
private string _valuesCacheKey;
// define constant - determines whether to use cache when previewing
// to store eg routes, property converted values, anything - caching
// means faster execution, but uses memory - not sure if we want it
// so making it configurable.
private const bool FullCacheWhenPreviewing = true;
public PublishedElementPropertyBase(IPublishedPropertyType propertyType, IPublishedElement element, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue = null, IPublishedSnapshotAccessor publishedSnapshotAccessor = null)
: base(propertyType, referenceCacheLevel)
{
_sourceValue = sourceValue;
_publishedSnapshotAccessor = publishedSnapshotAccessor;
Element = element;
IsPreviewing = previewing;
IsMember = propertyType.ContentType.ItemType == PublishedItemType.Member;
}
public override bool HasValue(string culture = null, string segment = null)
{
var hasValue = PropertyType.IsValue(_sourceValue, PropertyValueLevel.Source);
if (hasValue.HasValue) return hasValue.Value;
GetCacheLevels(out var cacheLevel, out var referenceCacheLevel);
lock (_locko)
{
var value = GetInterValue();
hasValue = PropertyType.IsValue(value, PropertyValueLevel.Inter);
if (hasValue.HasValue) return hasValue.Value;
var cacheValues = GetCacheValues(cacheLevel);
if (!cacheValues.ObjectInitialized)
{
cacheValues.ObjectValue = PropertyType.ConvertInterToObject(Element, referenceCacheLevel, value, IsPreviewing);
cacheValues.ObjectInitialized = true;
}
value = cacheValues.ObjectValue;
return PropertyType.IsValue(value, PropertyValueLevel.Object) ?? false;
}
}
// used to cache the CacheValues of this property
// ReSharper disable InconsistentlySynchronizedField
internal string ValuesCacheKey => _valuesCacheKey
?? (_valuesCacheKey = PropertyCacheValues(Element.Key, Alias, IsPreviewing));
// ReSharper restore InconsistentlySynchronizedField
protected class CacheValues
{
public bool ObjectInitialized;
public object ObjectValue;
public bool XPathInitialized;
public object XPathValue;
}
public static string PropertyCacheValues(Guid contentUid, string typeAlias, bool previewing)
{
return "PublishedSnapshot.Property.CacheValues[" + (previewing ? "D:" : "P:") + contentUid + ":" + typeAlias + "]";
}
private void GetCacheLevels(out PropertyCacheLevel cacheLevel, out PropertyCacheLevel referenceCacheLevel)
{
// based upon the current reference cache level (ReferenceCacheLevel) and this property
// cache level (PropertyType.CacheLevel), determines both the actual cache level for the
// property, and the new reference cache level.
// if the property cache level is 'shorter-termed' that the reference
// then use it and it becomes the new reference, else use Content and
// don't change the reference.
//
// examples:
// currently (reference) caching at published snapshot, property specifies
// elements, ok to use element. OTOH, currently caching at elements,
// property specifies snapshot, need to use snapshot.
//
if (PropertyType.CacheLevel > ReferenceCacheLevel || PropertyType.CacheLevel == PropertyCacheLevel.None)
{
cacheLevel = PropertyType.CacheLevel;
referenceCacheLevel = cacheLevel;
}
else
{
cacheLevel = PropertyCacheLevel.Element;
referenceCacheLevel = ReferenceCacheLevel;
}
}
private IAppCache GetSnapshotCache()
{
// cache within the snapshot cache, unless previewing, then use the snapshot or
// elements cache (if we don't want to pollute the elements cache with short-lived
// data) depending on settings
// for members, always cache in the snapshot cache - never pollute elements cache
var publishedSnapshot = _publishedSnapshotAccessor?.PublishedSnapshot;
if (publishedSnapshot == null) return null;
return (IsPreviewing == false || FullCacheWhenPreviewing) && IsMember == false
? publishedSnapshot.ElementsCache
: publishedSnapshot.SnapshotCache;
}
private CacheValues GetCacheValues(PropertyCacheLevel cacheLevel)
{
CacheValues cacheValues;
switch (cacheLevel)
{
case PropertyCacheLevel.None:
// never cache anything
cacheValues = new CacheValues();
break;
case PropertyCacheLevel.Element:
// cache within the property object itself, ie within the content object
cacheValues = _cacheValues ?? (_cacheValues = new CacheValues());
break;
case PropertyCacheLevel.Elements:
// cache within the elements cache, depending...
var snapshotCache = GetSnapshotCache();
cacheValues = (CacheValues) snapshotCache?.Get(ValuesCacheKey, () => new CacheValues()) ?? new CacheValues();
break;
case PropertyCacheLevel.Snapshot:
// cache within the snapshot cache
var facadeCache = _publishedSnapshotAccessor?.PublishedSnapshot?.SnapshotCache;
cacheValues = (CacheValues) facadeCache?.Get(ValuesCacheKey, () => new CacheValues()) ?? new CacheValues();
break;
default:
throw new InvalidOperationException("Invalid cache level.");
}
return cacheValues;
}
private object GetInterValue()
{
if (_interInitialized) return _interValue;
_interValue = PropertyType.ConvertSourceToInter(Element, _sourceValue, IsPreviewing);
_interInitialized = true;
return _interValue;
}
public override object GetSourceValue(string culture = null, string segment = null) => _sourceValue;
public override object GetValue(string culture = null, string segment = null)
{
GetCacheLevels(out var cacheLevel, out var referenceCacheLevel);
lock (_locko)
{
var cacheValues = GetCacheValues(cacheLevel);
if (cacheValues.ObjectInitialized) return cacheValues.ObjectValue;
cacheValues.ObjectValue = PropertyType.ConvertInterToObject(Element, referenceCacheLevel, GetInterValue(), IsPreviewing);
cacheValues.ObjectInitialized = true;
return cacheValues.ObjectValue;
}
}
public override object GetXPathValue(string culture = null, string segment = null)
{
GetCacheLevels(out var cacheLevel, out var referenceCacheLevel);
lock (_locko)
{
var cacheValues = GetCacheValues(cacheLevel);
if (cacheValues.XPathInitialized) return cacheValues.XPathValue;
cacheValues.XPathValue = PropertyType.ConvertInterToXPath(Element, referenceCacheLevel, GetInterValue(), IsPreviewing);
cacheValues.XPathInitialized = true;
return cacheValues.XPathValue;
}
}
}
}