Ejemplo n.º 1
0
 /// <summary>
 /// Calls any methods designed to handle <see cref="ConvertingTypeEventArgs"/> events.
 /// </summary>
 /// <param name="args">
 /// The <see cref="ConvertingTypeEventArgs"/>.
 /// </param>
 public static void CallConvertingTypeHandler(ConvertingTypeEventArgs args)
 {
     if (ConvertingType != null)
     {
         ConvertingType(null, args);
     }
 }
Ejemplo n.º 2
0
 /// <summary>
 /// Calls any methods designed to handle <see cref="ConvertingTypeEventArgs"/> events.
 /// </summary>
 /// <param name="args">
 /// The <see cref="ConvertingTypeEventArgs"/>.
 /// </param>
 public static void CallConvertingTypeHandler(ConvertingTypeEventArgs args)
 {
     if (ConvertingType != null)
     {
         ConvertingType(null, args);
     }
 }
        /// <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="convertingType">
        /// The <see cref="Action{ConvertingTypeEventArgs}"/> to fire when converting.
        /// </param>
        /// <param name="convertedType">
        /// The <see cref="Action{ConvertedTypeEventArgs}"/> to fire when converted.
        /// </param>
        /// <returns>
        /// The converted <see cref="Object"/> as the given type.
        /// </returns>
        public static object As(
            this IPublishedContent content,
            Type type,
            Action <ConvertingTypeEventArgs> convertingType = null,
            Action <ConvertedTypeEventArgs> convertedType   = null,
            CultureInfo culture = null)
        {
            if (content == null)
            {
                return(null);
            }

            using (DisposableTimer.DebugDuration(type, string.Format("IPublishedContent As ({0})", content.DocumentTypeAlias), "Complete"))
            {
                // Check for and fire any event args
                var convertingArgs = new ConvertingTypeEventArgs
                {
                    Content = content
                };

                EventHandlers.CallConvertingTypeHandler(convertingArgs);

                if (!convertingArgs.Cancel && convertingType != null)
                {
                    convertingType(convertingArgs);
                }

                // Cancel if applicable.
                if (convertingArgs.Cancel)
                {
                    return(null);
                }

                // Create an object and fetch it as the type.
                object instance = GetTypedProperty(content, type, culture);

                // Fire the converted event
                var convertedArgs = new ConvertedTypeEventArgs
                {
                    Content       = content,
                    Converted     = instance,
                    ConvertedType = type
                };

                if (convertedType != null)
                {
                    convertedType(convertedArgs);
                }

                EventHandlers.CallConvertedTypeHandler(convertedArgs);

                return(convertedArgs.Converted);
            }
        }
Ejemplo n.º 4
0
        public static T As <T>(this IPublishedContent content)
            where T : class
        {
            using (var t = DisposableTimer.DebugDuration <T>(string.Format("As ({0})", content.DocumentTypeAlias)))
            {
                var type = typeof(T);
                T   instance;

                var constructor = type.GetConstructors()
                                  .OrderBy(x => x.GetParameters().Length)
                                  .First();
                var constructorParams = constructor.GetParameters();

                var args1 = new ConvertingTypeEventArgs {
                    Content = content
                };
                CallConvertingTypeHandler(args1);

                if (args1.Cancel)
                {
                    return(null);
                }

                if (constructorParams.Length == 0)
                {
                    instance = Activator.CreateInstance(type) as T;
                }
                else if (constructorParams.Length == 1 & constructorParams[0].ParameterType == typeof(IPublishedContent))
                {
                    instance = Activator.CreateInstance(type, content) as T;
                }
                else
                {
                    throw new InvalidOperationException("Type {0} has invalid constructor parameters");
                }

                var properties  = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
                var contentType = content.GetType();

                foreach (var propertyInfo in properties.Where(x => x.CanWrite))
                {
                    using (var propertyLoopTimer = DisposableTimer.DebugDuration <T>(string.Format("ForEach Property ({1} {0})", propertyInfo.Name, content.Id)))
                    {
                        var    umbracoPropertyName    = propertyInfo.Name;
                        var    altUmbracoPropertyName = "";
                        var    recursive    = false;
                        object defaultValue = null;

                        var umbracoPropertyAttr = propertyInfo.GetCustomAttribute <UmbracoPropertyAttribute>();
                        if (umbracoPropertyAttr != null)
                        {
                            umbracoPropertyName    = umbracoPropertyAttr.PropertyName;
                            altUmbracoPropertyName = umbracoPropertyAttr.AltPropertyName;
                            recursive    = umbracoPropertyAttr.Recursive;
                            defaultValue = umbracoPropertyAttr.DefaultValue;
                        }

                        // Try fetching the value
                        var contentProperty = contentType.GetProperty(umbracoPropertyName);
                        var propertyValue   = contentProperty != null
                                                        ? contentProperty.GetValue(content, null)
                                                        : content.GetPropertyValue(umbracoPropertyName,
                                                                                   recursive);

                        // Try fetching the alt value
                        if (propertyValue == null && !string.IsNullOrWhiteSpace(altUmbracoPropertyName))
                        {
                            contentProperty = contentType.GetProperty(altUmbracoPropertyName);
                            propertyValue   = contentProperty != null
                                                                ? contentProperty.GetValue(content, null)
                                                                : content.GetPropertyValue(altUmbracoPropertyName,
                                                                                           recursive);
                        }

                        // Try setting the default value
                        if (propertyValue == null && defaultValue != null)
                        {
                            propertyValue = defaultValue;
                        }

                        // Process the value
                        if (propertyValue != null)
                        {
                            if (propertyInfo.PropertyType.IsInstanceOfType(propertyValue))
                            {
                                propertyInfo.SetValue(instance, propertyValue, null);
                            }
                            else
                            {
                                using (var typeConverterTimer = DisposableTimer.DebugDuration <T>(string.Format("TypeConverter ({1} {0})", propertyInfo.Name, content.Id)))
                                {
                                    var converterAttr = propertyInfo.GetCustomAttribute <TypeConverterAttribute>();
                                    if (converterAttr != null)
                                    {
                                        var converter = Activator.CreateInstance(Type.GetType(converterAttr.ConverterTypeName)) as TypeConverter;
                                        propertyInfo.SetValue(instance, converter.ConvertFrom(propertyValue), null);
                                    }
                                    else
                                    {
                                        var convert = propertyValue.TryConvertTo(propertyInfo.PropertyType);
                                        if (convert.Success)
                                        {
                                            propertyInfo.SetValue(instance, convert.Result, null);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                var args2 = new ConvertedTypeEventArgs
                {
                    Content       = content,
                    Converted     = instance,
                    ConvertedType = typeof(T)
                };

                CallConvertedTypeHandler(args2);

                return(args2.Converted as T);
            }
        }