/// <summary>Returns the processed value for the given type and property.</summary>
/// <param name="content">The <see cref="IPublishedContent" /> to convert.</param>
/// <param name="culture">The <see cref="CultureInfo" /></param>
/// <param name="config">The Ditto configuration for the type.</param>
/// <param name="mappableProperty">Information about the mappable property.</param>
/// <param name="instance">The instance to assign the value to.</param>
/// <param name="chainContext">The <see cref="DittoChainContext"/> for the current processor chain.</param>
/// <returns>The <see cref="object" /> representing the Umbraco value.</returns>
private static object GetProcessedValue(
IPublishedContent content,
CultureInfo culture,
DittoTypeInfo config,
DittoTypeInfo.DittoTypePropertyInfo mappableProperty,
object instance,
DittoChainContext chainContext)
{
using (DittoDisposableTimer.DebugDuration(typeof(Ditto), $"Processing '{mappableProperty.PropertyInfo.Name}' ({content.Id})"))
{
// Create a base processor context for this current chain level
var baseProcessorContext = new DittoProcessorContext
{
Content = content,
TargetType = config.TargetType,
PropertyInfo = mappableProperty.PropertyInfo,
Culture = culture
};
// Check for cache attribute
if (mappableProperty.IsCacheable)
{
var ctx = new DittoCacheContext(mappableProperty.CacheInfo, content, config.TargetType, mappableProperty.PropertyInfo, culture);
return(mappableProperty.CacheInfo.GetCacheItem(ctx, () => DoGetProcessedValue(content, mappableProperty, baseProcessorContext, chainContext)));
}
else
{
return(DoGetProcessedValue(content, mappableProperty, baseProcessorContext, chainContext));
}
}
}
/// <summary>
/// Processes the value.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="context">The context.</param>
/// <param name="chainContext">The chain context.</param>
/// <returns>
/// The <see cref="object" /> representing the processed value.
/// </returns>
internal virtual object ProcessValue(
object value,
DittoProcessorContext context,
DittoChainContext chainContext)
{
if (value != null && this.ValueType.IsInstanceOfType(value) == false)
{
throw new ArgumentException($"Expected a value argument of type {this.ValueType} but got {value.GetType()}", "value");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (this.ContextType.IsInstanceOfType(context) == false)
{
throw new ArgumentException($"Expected a context argument of type {this.ContextType} but got {context.GetType()}", "context");
}
if (chainContext == null)
{
throw new ArgumentNullException("chainContext");
}
this.Value = value;
this.Context = context;
this.ChainContext = chainContext;
var ctx = new DittoCacheContext(this, context.Content, context.TargetType, context.PropertyInfo, context.Culture);
return(this.GetCacheItem(ctx, this.ProcessValue));
}
/// <summary>
/// Returns an object representing the given <see cref="Type"/>.
/// </summary>
/// <param name="content">
/// The <see cref="IPublishedContent"/> to convert.
/// </param>
/// <param name="type">
/// The <see cref="Type"/> of items to return.
/// </param>
/// <param name="culture">
/// The <see cref="CultureInfo"/>
/// </param>
/// <param name="instance">
/// An existing instance of T to populate
/// </param>
/// <param name="processorContexts">
/// A collection of <see cref="DittoProcessorContext"/> entities to use whilst processing values.
/// </param>
/// <param name="onConverting">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converting.
/// </param>
/// <param name="onConverted">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converted.
/// </param>
/// <param name="chainContext">
/// The <see cref="DittoChainContext"/> for the current processor chain.
/// </param>
/// <returns>
/// The converted <see cref="Object"/> as the given type.
/// </returns>
public static object As(
this IPublishedContent content,
Type type,
CultureInfo culture = null,
object instance = null,
IEnumerable <DittoProcessorContext> processorContexts = null,
Action <DittoConversionHandlerContext> onConverting = null,
Action <DittoConversionHandlerContext> onConverted = null,
DittoChainContext chainContext = null)
{
// Ensure content
if (content == null)
{
return(null);
}
// Ensure instance is of target type
if (instance != null && !type.IsInstanceOfType(instance))
{
throw new ArgumentException($"The instance parameter does not implement Type '{type.Name}'", nameof(instance));
}
// Get the context accessor (for access to ApplicationContext, UmbracoContext, et al)
var contextAccessor = (IDittoContextAccessor)Ditto.GetContextAccessorType().GetInstance();
// Check if the culture has been set, otherwise use from Umbraco, or fallback to a default
if (culture == null)
{
culture = contextAccessor.UmbracoContext?.PublishedContentRequest != null
? contextAccessor.UmbracoContext.PublishedContentRequest.Culture
: CultureInfo.CurrentCulture;
}
// Ensure a chain context
if (chainContext == null)
{
chainContext = new DittoChainContext();
}
// Populate prcessor contexts collection with any passed in contexts
chainContext.ProcessorContexts.AddRange(processorContexts);
// Convert
using (DittoDisposableTimer.DebugDuration <Ditto>($"As<{type.Name}>({content.DocumentTypeAlias} {content.Id})"))
{
var cacheAttr = type.GetCustomAttribute <DittoCacheAttribute>(true);
if (cacheAttr != null)
{
var ctx = new DittoCacheContext(cacheAttr, content, type, culture);
return(cacheAttr.GetCacheItem(ctx, () => ConvertContent(content, type, contextAccessor, culture, instance, onConverting, onConverted, chainContext)));
}
else
{
return(ConvertContent(content, type, contextAccessor, culture, instance, onConverting, onConverted, chainContext));
}
}
}
/// <summary>
/// Gets a collection of the given type from the given <see cref="IEnumerable{IPublishedContent}"/>.
/// </summary>
/// <param name="items">
/// The <see cref="IEnumerable{IPublishedContent}"/> to convert.
/// </param>
/// <param name="culture">The <see cref="CultureInfo"/></param>
/// <param name="processorContexts">
/// A collection of <see cref="DittoProcessorContext"/> entities to use whilst processing values.
/// </param>
/// <param name="onConverting">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converting.
/// </param>
/// <param name="onConverted">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converted.
/// </param>
/// <param name="chainContext">
/// The <see cref="DittoChainContext"/> for the current processor chain.
/// </param>
/// <typeparam name="T">
/// The <see cref="Type"/> of items to return.
/// </typeparam>
/// <returns>
/// The converted <see cref="IEnumerable{T}"/>.
/// </returns>
public static IEnumerable <T> As <T>(
this IEnumerable <IPublishedContent> items,
CultureInfo culture = null,
IEnumerable <DittoProcessorContext> processorContexts = null,
Action <DittoConversionHandlerContext> onConverting = null,
Action <DittoConversionHandlerContext> onConverted = null,
DittoChainContext chainContext = null)
where T : class
{
return(items.As(typeof(T), culture, processorContexts, onConverting, onConverted, chainContext).Select(x => x as T));
}
/// <summary>
/// Returns the given instance of <see cref="IPublishedContent"/> as the specified type.
/// </summary>
/// <param name="content">
/// The <see cref="IPublishedContent"/> to convert.
/// </param>
/// <param name="culture">
/// The <see cref="CultureInfo"/>
/// </param>
/// <param name="instance">
/// An existing instance of T to populate
/// </param>
/// <param name="processorContexts">
/// A collection of <see cref="DittoProcessorContext"/> entities to use whilst processing values.
/// </param>
/// <param name="onConverting">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converting.
/// </param>
/// <param name="onConverted">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converted.
/// </param>
/// <param name="chainContext">
/// The <see cref="DittoChainContext"/> for the current processor chain.
/// </param>
/// <typeparam name="T">
/// The <see cref="Type"/> of items to return.
/// </typeparam>
/// <returns>
/// The converted generic <see cref="Type"/>.
/// </returns>
public static T As <T>(
this IPublishedContent content,
CultureInfo culture = null,
T instance = null,
IEnumerable <DittoProcessorContext> processorContexts = null,
Action <DittoConversionHandlerContext> onConverting = null,
Action <DittoConversionHandlerContext> onConverted = null,
DittoChainContext chainContext = null)
where T : class
{
return(content.As(typeof(T), culture, instance, processorContexts, onConverting, onConverted, chainContext) as T);
}
/// <summary>Returns an object representing the given <see cref="Type"/>.</summary>
/// <param name="content">The <see cref="IPublishedContent"/> to convert.</param>
/// <param name="type">The <see cref="Type"/> of items to return.</param>
/// <param name="culture">The <see cref="CultureInfo"/></param>
/// <param name="instance">An existing instance of T to populate</param>
/// <param name="processorContexts">A collection of <see cref="DittoProcessorContext"/> entities to use whilst processing values.</param>
/// <param name="onConverting">The <see cref="Action{ConversionHandlerContext}"/> to fire when converting.</param>
/// <param name="onConverted">The <see cref="Action{ConversionHandlerContext}"/> to fire when converted.</param>
/// <param name="chainContext">The <see cref="DittoChainContext"/> for the current processor chain.</param>
/// <returns>The converted <see cref="Object"/> as the given type.</returns>
public static object As(
this IPublishedContent content,
Type type,
CultureInfo culture = null,
object instance = null,
IEnumerable <DittoProcessorContext> processorContexts = null,
Action <DittoConversionHandlerContext> onConverting = null,
Action <DittoConversionHandlerContext> onConverted = null,
DittoChainContext chainContext = null)
{
// Ensure content
if (content == null)
{
return(null);
}
// Ensure instance is of target type
if (instance != null && type.IsInstanceOfType(instance) == false)
{
throw new ArgumentException($"The instance parameter does not implement Type '{type.Name}'", nameof(instance));
}
// Check if the culture has been set, otherwise use from Umbraco, or fallback to a default
if (culture == null)
{
culture = ContextAccessor?.UmbracoContext?.PublishedContentRequest?.Culture ?? CultureInfo.CurrentCulture;
}
// Ensure a chain context
if (chainContext == null)
{
chainContext = new DittoChainContext();
}
// Populate prcessor contexts collection with any passed in contexts
chainContext.ProcessorContexts.AddRange(processorContexts);
// Convert
using (DittoDisposableTimer.DebugDuration(typeof(Ditto), $"As<{type.Name}>({content.DocumentTypeAlias} {content.Id})"))
{
var config = DittoTypeInfoCache.GetOrAdd(type);
if (config.IsCacheable)
{
var ctx = new DittoCacheContext(config.CacheInfo, content, type, culture);
return(config.CacheInfo.GetCacheItem(ctx, () => ConvertContent(content, config, culture, instance, onConverting, onConverted, chainContext)));
}
else
{
return(ConvertContent(content, config, culture, instance, onConverting, onConverted, chainContext));
}
}
}
/// <summary>
/// Gets a collection of the given type from the given <see cref="IEnumerable{IPublishedContent}"/>.
/// </summary>
/// <param name="items">
/// The <see cref="IEnumerable{IPublishedContent}"/> to convert.
/// </param>
/// <param name="type">
/// The <see cref="Type"/> of items to return.
/// </param>
/// <param name="culture">
/// The <see cref="CultureInfo"/>.
/// </param>
/// <param name="processorContexts">
/// A collection of <see cref="DittoProcessorContext"/> entities to use whilst processing values.
/// </param>
/// <param name="onConverting">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converting.
/// </param>
/// <param name="onConverted">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converted.
/// </param>
/// <param name="chainContext">
/// The <see cref="DittoChainContext"/> for the current processor chain.
/// </param>
/// <returns>
/// The converted <see cref="IEnumerable{T}"/>.
/// </returns>
public static IEnumerable <object> As(
this IEnumerable <IPublishedContent> items,
Type type,
CultureInfo culture = null,
IEnumerable <DittoProcessorContext> processorContexts = null,
Action <DittoConversionHandlerContext> onConverting = null,
Action <DittoConversionHandlerContext> onConverted = null,
DittoChainContext chainContext = null)
{
using (DittoDisposableTimer.DebugDuration <Ditto>($"IEnumerable As<{type.Name}>"))
{
var typedItems = items.Select(x => x.As(type, culture, null, processorContexts, onConverting, onConverted, chainContext));
// We need to cast back here as nothing is strong typed anymore.
return((IEnumerable <object>)EnumerableInvocations.Cast(type, typedItems));
}
}
/// <summary>Returns the processed value for the given type and property.</summary>
/// <param name="content">The content.</param>
/// <param name="mappableProperty">Information about the mappable property.</param>
/// <param name="baseProcessorContext">The base processor context.</param>
/// <param name="chainContext">The <see cref="DittoChainContext"/> for the current processor chain.</param>
/// <returns>Returns the processed value.</returns>
private static object DoGetProcessedValue(
IPublishedContent content,
DittoTypeInfo.DittoTypePropertyInfo mappableProperty,
DittoProcessorContext baseProcessorContext,
DittoChainContext chainContext)
{
// Create holder for value as it's processed
object currentValue = content;
// Process attributes
foreach (var processorAttr in mappableProperty.Processors)
{
using (DittoDisposableTimer.DebugDuration(typeof(Ditto), $"Processor '{processorAttr}' ({content.Id})"))
{
// Get the right context type
var ctx = chainContext.ProcessorContexts.GetOrCreate(baseProcessorContext, processorAttr.ContextType);
// Populate UmbracoContext & ApplicationContext
processorAttr.UmbracoContext = ContextAccessor.UmbracoContext;
processorAttr.ApplicationContext = ContextAccessor.ApplicationContext;
// Process value
currentValue = processorAttr.ProcessValue(currentValue, ctx, chainContext);
}
}
// The following has to happen after all the processors.
if (mappableProperty.IsEnumerable && currentValue != null && currentValue.Equals(Enumerable.Empty <object>()))
{
if (mappableProperty.PropertyInfo.PropertyType.IsInterface)
{
// You cannot set an enumerable of type from an empty object array.
currentValue = EnumerableInvocations.Cast(mappableProperty.EnumerableType, (IEnumerable)currentValue);
}
else
{
// This should allow the casting back of IEnumerable<T> to an empty List<T> Collection<T> etc.
// I cant think of any that don't have an empty constructor
currentValue = mappableProperty.PropertyInfo.PropertyType.GetInstance();
}
}
return(currentValue == null && mappableProperty.PropertyInfo.PropertyType.IsValueType
? mappableProperty.PropertyInfo.PropertyType.GetInstance() // Set to default instance of value type
: currentValue);
}
/// <summary>
/// Returns the processed value for the given type and property.
/// </summary>
/// <param name="content">The <see cref="IPublishedContent" /> to convert.</param>
/// <param name="culture">The <see cref="CultureInfo" /></param>
/// <param name="targetType">The target type.</param>
/// <param name="propertyInfo">The <see cref="PropertyInfo" /> property info associated with the type.</param>
/// <param name="instance">The instance to assign the value to.</param>
/// <param name="contextAccessor">The context accessor.</param>
/// <param name="chainContext">The <see cref="DittoChainContext"/> for the current processor chain.</param>
/// <returns>
/// The <see cref="object" /> representing the Umbraco value.
/// </returns>
private static object GetProcessedValue(
IPublishedContent content,
CultureInfo culture,
Type targetType,
PropertyInfo propertyInfo,
object instance,
IDittoContextAccessor contextAccessor,
DittoChainContext chainContext)
{
using (DittoDisposableTimer.DebugDuration <Ditto>($"Processing '{propertyInfo.Name}' ({content.Id})"))
{
// Get the target property description
var propertyDescriptor = TypeDescriptor.GetProperties(instance)[propertyInfo.Name];
// Create a base processor context for this current chain level
var baseProcessorContext = new DittoProcessorContext
{
Content = content,
TargetType = targetType,
PropertyDescriptor = propertyDescriptor,
Culture = culture
};
// Check for cache attribute
var cacheAttr = propertyInfo.GetCustomAttribute <DittoCacheAttribute>(true);
if (cacheAttr != null)
{
var ctx = new DittoCacheContext(cacheAttr, content, targetType, propertyDescriptor, culture);
return(cacheAttr.GetCacheItem(ctx, () => DoGetProcessedValue(content, propertyInfo, contextAccessor, baseProcessorContext, chainContext)));
}
else
{
return(DoGetProcessedValue(content, propertyInfo, contextAccessor, baseProcessorContext, chainContext));
}
}
}
/// <summary>
/// Returns the processed value for the given type and property.
/// </summary>
/// <param name="content">The content.</param>
/// <param name="propertyInfo">The property information.</param>
/// <param name="contextAccessor">The context accessor.</param>
/// <param name="baseProcessorContext">The base processor context.</param>
/// <param name="chainContext">The <see cref="DittoChainContext"/> for the current processor chain.</param>
/// <returns>Returns the processed value.</returns>
private static object DoGetProcessedValue(
IPublishedContent content,
PropertyInfo propertyInfo,
IDittoContextAccessor contextAccessor,
DittoProcessorContext baseProcessorContext,
DittoChainContext chainContext)
{
// Check the property for any explicit processor attributes
var processorAttrs = propertyInfo.GetCustomAttributes <DittoProcessorAttribute>(true)
.OrderBy(x => x.Order)
.ToList();
if (!processorAttrs.Any())
{
// Adds the default processor for this conversion
processorAttrs.Add(DittoProcessorRegistry.Instance.GetDefaultProcessorFor(baseProcessorContext.TargetType));
}
var propertyType = propertyInfo.PropertyType;
// Check for type registered processors
processorAttrs.AddRange(propertyType
.GetCustomAttributes <DittoProcessorAttribute>(true)
.OrderBy(x => x.Order));
// Check any type arguments in generic enumerable types.
// This should return false against typeof(string) etc also.
var typeInfo = propertyType.GetTypeInfo();
bool isEnumerable = false;
Type typeArg = null;
if (propertyType.IsCastableEnumerableType())
{
typeArg = typeInfo.GenericTypeArguments.First();
processorAttrs.AddRange(typeInfo
.GenericTypeArguments
.First()
.GetCustomAttributes <DittoProcessorAttribute>(true)
.OrderBy(x => x.Order)
.ToList());
isEnumerable = true;
}
// Check for globally registered processors
processorAttrs.AddRange(DittoProcessorRegistry.Instance.GetRegisteredProcessorAttributesFor(propertyInfo.PropertyType));
// Add any core processors onto the end
processorAttrs.AddRange(DittoProcessorRegistry.Instance.GetPostProcessorAttributes());
// Create holder for value as it's processed
object currentValue = content;
// Process attributes
foreach (var processorAttr in processorAttrs)
{
using (DittoDisposableTimer.DebugDuration <Ditto>($"Processor '{processorAttr.GetType().Name}' ({content.Id})"))
{
// Get the right context type
var ctx = chainContext.ProcessorContexts.GetOrCreate(baseProcessorContext, processorAttr.ContextType);
// Populate UmbracoContext & ApplicationContext
processorAttr.UmbracoContext = contextAccessor.UmbracoContext;
processorAttr.ApplicationContext = contextAccessor.ApplicationContext;
// Process value
currentValue = processorAttr.ProcessValue(currentValue, ctx, chainContext);
}
}
// The following has to happen after all the processors.
if (isEnumerable && currentValue != null && currentValue.Equals(Enumerable.Empty <object>()))
{
if (propertyType.IsInterface)
{
// You cannot set an enumerable of type from an empty object array.
currentValue = EnumerableInvocations.Cast(typeArg, (IEnumerable)currentValue);
}
else
{
// This should allow the casting back of IEnumerable<T> to an empty List<T> Collection<T> etc.
// I cant think of any that don't have an empty constructor
currentValue = propertyType.GetInstance();
}
}
return((currentValue == null && propertyType.IsValueType)
? propertyInfo.PropertyType.GetInstance() // Set to default instance of value type
: currentValue);
}
/// <summary>
/// Returns an object representing the given <see cref="Type"/>.
/// </summary>
/// <param name="content">
/// The <see cref="IPublishedContent"/> to convert.
/// </param>
/// <param name="type">
/// The <see cref="Type"/> of items to return.
/// </param>
/// <param name="contextAccessor">
/// The context accessor.
/// </param>
/// <param name="culture">
/// The <see cref="CultureInfo"/>
/// </param>
/// <param name="instance">
/// An existing instance of T to populate
/// </param>
/// <param name="onConverting">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converting.
/// </param>
/// <param name="onConverted">
/// The <see cref="Action{ConversionHandlerContext}"/> to fire when converted.
/// </param>
/// <param name="chainContext">
/// The <see cref="DittoChainContext"/> for the current processor chain.
/// </param>
/// <returns>
/// The converted <see cref="Object"/> as the given type.
/// </returns>
/// <exception cref="InvalidOperationException">
/// Thrown if the given type has invalid constructors.
/// </exception>
private static object ConvertContent(
IPublishedContent content,
Type type,
IDittoContextAccessor contextAccessor,
CultureInfo culture,
object instance,
Action <DittoConversionHandlerContext> onConverting,
Action <DittoConversionHandlerContext> onConverted,
DittoChainContext chainContext)
{
// Collect all the properties of the given type and loop through writable ones.
PropertyInfo[] properties;
PropertyCache.TryGetValue(type, out properties);
if (properties == null)
{
properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(x => x.CanWrite && x.GetSetMethod() != null).ToArray();
PropertyCache.TryAdd(type, properties);
}
// Check the validity of the mpped type constructor as early as possible.
ParameterInfo[] constructorParams = type.GetConstructorParameters();
bool validConstructor = false;
bool hasParameter = false;
bool isType = false;
bool hasLazy = false;
if (constructorParams != null)
{
// Is it PublishedContentmModel or similar?
if (constructorParams.Length == 1 && constructorParams[0].ParameterType == typeof(IPublishedContent))
{
hasParameter = true;
}
if (constructorParams.Length == 0 || hasParameter)
{
validConstructor = true;
}
}
// No valid constructor, but see if the value can be cast to the type
if (type.IsInstanceOfType(content))
{
isType = true;
validConstructor = true;
}
if (!validConstructor)
{
throw new InvalidOperationException(
$"Cannot convert IPublishedContent to {type} as it has no valid constructor. " +
"A valid constructor is either an empty one, or one accepting a single IPublishedContent parameter.");
}
PropertyInfo[] lazyProperties = null;
// If not already an instance, create an instance of the object
if (instance == null)
{
// We can only proxy new instances.
lazyProperties = properties.Where(x => x.ShouldAttemptLazyLoad()).ToArray();
if (lazyProperties.Any())
{
hasLazy = true;
var factory = new ProxyFactory();
instance = hasParameter
? factory.CreateProxy(type, lazyProperties.Select(x => x.Name), content)
: factory.CreateProxy(type, lazyProperties.Select(x => x.Name));
}
else if (isType)
{
instance = content;
}
else
{
// 1: This extension method is about 7x faster than the native implementation.
// 2: Internally this uses Activator.CreateInstance which is heavily optimized.
instance = hasParameter
? type.GetInstance(content) // 1
: type.GetInstance(); // 2
}
}
// We have the instance object but haven't yet populated properties
// so fire the on converting event handlers
OnConverting(content, type, culture, instance, onConverting);
if (hasLazy)
{
// A dictionary to store lazily invoked values.
var lazyMappings = new Dictionary <string, Lazy <object> >();
foreach (var propertyInfo in lazyProperties)
{
// Configure lazy properties
using (DittoDisposableTimer.DebugDuration <Ditto>($"Lazy Property ({content.Id} {propertyInfo.Name})"))
{
// Ensure it's a virtual property (Only relevant to property level lazy loads)
if (!propertyInfo.IsVirtualAndOverridable())
{
throw new InvalidOperationException($"Lazy property '{propertyInfo.Name}' of type '{type.AssemblyQualifiedName}' must be declared virtual in order to be lazy loadable.");
}
lazyMappings.Add(propertyInfo.Name, new Lazy <object>(() => GetProcessedValue(content, culture, type, propertyInfo, instance, contextAccessor, chainContext)));
}
}
((IProxy)instance).Interceptor = new LazyInterceptor(lazyMappings);
}
// Process any non lazy properties
foreach (var propertyInfo in properties.Where(x => !x.ShouldAttemptLazyLoad()))
{
// Check for the ignore attribute.
if (propertyInfo.HasCustomAttribute <DittoIgnoreAttribute>())
{
continue;
}
// Set the value normally.
var value = GetProcessedValue(content, culture, type, propertyInfo, instance, contextAccessor, chainContext);
// This over 4x faster as propertyInfo.SetValue(instance, value, null);
FastPropertyAccessor.SetValue(propertyInfo, instance, value);
}
// We have now finished populating the instance object so go ahead
// and fire the on converted event handlers
OnConverted(content, type, culture, instance, onConverted);
return(instance);
}
/// <summary>Returns an object representing the given <see cref="Type"/>.</summary>
/// <param name="content">The <see cref="IPublishedContent"/> to convert.</param>
/// <param name="config">The Ditto configuration for the type.</param>
/// <param name="culture">The <see cref="CultureInfo"/></param>
/// <param name="instance">An existing instance of T to populate</param>
/// <param name="onConverting">The <see cref="Action{ConversionHandlerContext}"/> to fire when converting.</param>
/// <param name="onConverted">The <see cref="Action{ConversionHandlerContext}"/> to fire when converted.</param>
/// <param name="chainContext">The <see cref="DittoChainContext"/> for the current processor chain.</param>
/// <returns>The converted <see cref="Object"/> as the given type.</returns>
/// <exception cref="InvalidOperationException">Thrown if the given type has invalid constructors.</exception>
private static object ConvertContent(
IPublishedContent content,
DittoTypeInfo config,
CultureInfo culture,
object instance,
Action <DittoConversionHandlerContext> onConverting,
Action <DittoConversionHandlerContext> onConverted,
DittoChainContext chainContext)
{
// If not already an instance, create an instance of the object.
if (instance == null)
{
// Check the validity of the mapped type constructor.
if (config.ConstructorIsValid == false)
{
throw new InvalidOperationException(
$"Cannot convert IPublishedContent to {config.TargetType} as it has no valid constructor. " +
"A valid constructor is either empty, or one accepting a single IPublishedContent parameter.");
}
// We can only proxy new instances.
if (config.ConstructorRequiresProxyType)
{
var factory = new ProxyFactory();
instance = config.ConstructorHasPublishedContentParameter
? factory.CreateProxy(config.TargetType, config.LazyPropertyNames, content)
: factory.CreateProxy(config.TargetType, config.LazyPropertyNames);
}
else if (config.IsOfTypePublishedContent)
{
instance = content;
}
else
{
// 1: This extension method is about 7x faster than the native implementation.
// 2: Internally this uses Activator.CreateInstance which is heavily optimized.
instance = config.ConstructorHasPublishedContentParameter
// TODO: Review this, as we could get the Constructor metadata from the "type-cache"?
? config.TargetType.GetInstance(content) // 1
: config.TargetType.GetInstance(); // 2
}
}
// We have the instance object but haven't yet populated properties
// so fire the on converting event handlers
OnConverting(content, config, culture, instance, onConverting);
if (config.HasLazyProperties)
{
// A dictionary to store lazily invoked values.
var lazyMappings = new Dictionary <string, Lazy <object> >();
foreach (var lazyProperty in config.LazyProperties)
{
// Configure lazy properties
lazyMappings.Add(lazyProperty.PropertyInfo.Name, new Lazy <object>(() => GetProcessedValue(content, culture, config, lazyProperty, instance, chainContext)));
}
((IProxy)instance).Interceptor = new LazyInterceptor(lazyMappings);
}
// Process any eager properties
if (config.HasEagerProperties)
{
foreach (var eagerProperty in config.EagerProperties)
{
// Set the value normally.
var value = GetProcessedValue(content, culture, config, eagerProperty, instance, chainContext);
// This over 4x faster as propertyInfo.SetValue(instance, value, null);
FastPropertyAccessor.SetValue(eagerProperty.PropertyInfo, instance, value);
}
}
// We have now finished populating the instance object so go ahead
// and fire the on converted event handlers
OnConverted(content, config, culture, instance, onConverted);
return(instance);
}