public override object GetValue(string culture = null, string segment = null)
{
// isPreviewing is true here since we want to preview anyway...
const bool isPreviewing = true;
var source = PropertyType.ConvertSourceToInter(_content, _sourceValue, isPreviewing);
return(PropertyType.ConvertInterToObject(_content, PropertyCacheLevel.Unknown, source, isPreviewing));
}
private object?GetInterValue()
{
if (_interInitialized)
{
return(_interValue);
}
_interValue = PropertyType.ConvertSourceToInter(Element, _sourceValue, IsPreviewing);
_interInitialized = true;
return(_interValue);
}
public RawValueProperty(IPublishedPropertyType propertyType, IPublishedElement content, object sourceValue, bool isPreviewing = false)
: base(propertyType, PropertyCacheLevel.Unknown) // cache level is ignored
{
if (propertyType.Variations != ContentVariation.Nothing)
{
throw new ArgumentException("Property types with variations are not supported here.", nameof(propertyType));
}
_sourceValue = sourceValue;
var interValue = new Lazy <object>(() => PropertyType.ConvertSourceToInter(content, _sourceValue, isPreviewing));
_objectValue = new Lazy <object>(() => PropertyType.ConvertInterToObject(content, PropertyCacheLevel.Unknown, interValue.Value, isPreviewing));
_xpathValue = new Lazy <object>(() => PropertyType.ConvertInterToXPath(content, PropertyCacheLevel.Unknown, interValue.Value, isPreviewing));
}
public override object GetValue(string culture = null, string segment = null)
{
// NOT caching the source (intermediate) value since we'll never need it
// everything in Xml cache is per-request anyways
// also, properties should not be shared between requests and therefore
// are single threaded, so the following code should be safe & fast
if (_objectValueComputed)
{
return(_objectValue);
}
var inter = PropertyType.ConvertSourceToInter(_content, _sourceValue, _isPreviewing);
// initial reference cache level always is .Content
_objectValue = PropertyType.ConvertInterToObject(_content, PropertyCacheLevel.Element, inter, _isPreviewing);
_objectValueComputed = true;
return(_objectValue);
}
// this is always invoked from within a lock, so does not require its own lock
private object GetInterValue(string culture, string segment)
{
if (culture == "" && segment == "")
{
if (_interInitialized)
{
return(_interValue);
}
_interValue = PropertyType.ConvertSourceToInter(_content, _sourceValue, _isPreviewing);
_interInitialized = true;
return(_interValue);
}
if (_sourceValues == null)
{
_sourceValues = new Dictionary <CompositeStringStringKey, SourceInterValue>();
}
var k = new CompositeStringStringKey(culture, segment);
if (!_sourceValues.TryGetValue(k, out var vvalue))
{
_sourceValues[k] = vvalue = new SourceInterValue {
Culture = culture, Segment = segment, SourceValue = GetSourceValue(culture, segment)
}
}
;
if (vvalue.InterInitialized)
{
return(vvalue.InterValue);
}
vvalue.InterValue = PropertyType.ConvertSourceToInter(_content, vvalue.SourceValue, _isPreviewing);
vvalue.InterInitialized = true;
return(vvalue.InterValue);
}