Beispiel #1
0
        /// <summary>
        /// Generates semantic markup (HTML/RDFa attributes) for a given property.
        /// </summary>
        /// <param name="htmlHelper">The HtmlHelper instance on which the extension method operates.</param>
        /// <param name="propertyExpression">A parameterless lambda expression which evaluates to a property of the current Entity Model.</param>
        /// <param name="index">The index of the property value (for multi-value properties).</param>
        /// <returns>The semantic markup (HTML/RDFa attributes).</returns>
        public static MvcHtmlString DxaPropertyMarkup(this HtmlHelper htmlHelper, Expression <Func <object> > propertyExpression, int index = 0)
        {
            MemberExpression memberExpression = propertyExpression.Body as MemberExpression;

            if (memberExpression == null)
            {
                UnaryExpression boxingExpression = propertyExpression.Body as UnaryExpression;
                if (boxingExpression != null)
                {
                    memberExpression = boxingExpression.Operand as MemberExpression;
                }
            }
            if (memberExpression == null)
            {
                throw new DxaException(
                          string.Format("Unexpected expression provided to DxaPropertyMarkup: {0}. Expecting a lambda which evaluates to an Entity Model property.", propertyExpression.Body.GetType().Name)
                          );
            }

            Expression <Func <object> > entityExpression = Expression.Lambda <Func <object> >(memberExpression.Expression);
            Func <object> entityLambda = entityExpression.Compile();
            object        entity       = entityLambda.Invoke();
            EntityModel   entityModel  = entity as EntityModel;

            if (entityModel == null)
            {
                throw new DxaException(
                          string.Format("Unexpected type used in DxaPropertyMarkup expression: {0}. Expecting a lambda which evaluates to an Entity Model property.", entity)
                          );
            }

            return(Markup.RenderPropertyAttributes(entityModel, memberExpression.Member, index));
        }
Beispiel #2
0
        /// <summary>
        /// Generates semantic markup (HTML/RDFa attributes) for a given property.
        /// </summary>
        /// <param name="htmlHelper">The HtmlHelper instance on which the extension method operates.</param>
        /// <param name="propertyExpression">A parameterless lambda expression which evaluates to a property of the current Entity Model.</param>
        /// <param name="index">The index of the property value (for multi-value properties).</param>
        /// <returns>The semantic markup (HTML/RDFa attributes).</returns>
        public static MvcHtmlString DxaPropertyMarkup(this HtmlHelper htmlHelper, Expression <Func <object> > propertyExpression, int index = 0)
        {
            MemberExpression memberExpression = propertyExpression.Body as MemberExpression;

            if (memberExpression == null)
            {
                UnaryExpression boxingExpression = propertyExpression.Body as UnaryExpression;
                if (boxingExpression != null)
                {
                    memberExpression = boxingExpression.Operand as MemberExpression;
                }
            }
            if (memberExpression == null)
            {
                throw new DxaException(
                          $"Unexpected expression provided to DxaPropertyMarkup: {propertyExpression.Body.GetType().Name}. Expecting a lambda which evaluates to an Entity Model property."
                          );
            }

            object           subject;
            MemberExpression subjectExpression = memberExpression.Expression as MemberExpression;

            if (subjectExpression != null && subjectExpression.Member.Name == "Model")
            {
                // Often the subject of the property expression is the current Model. For example: () => Model.Headline
                // This is a shortcut to prevent having to compile the subject expression for that case.
                subject = htmlHelper.ViewData.Model;
            }
            else
            {
                Expression <Func <object> > entityExpression = Expression.Lambda <Func <object> >(memberExpression.Expression);
                Func <object> entityLambda = entityExpression.Compile();
                subject = entityLambda.Invoke();
            }

            EntityModel entityModel = subject as EntityModel;

            if (entityModel == null)
            {
                throw new DxaException(
                          $"Unexpected type used in DxaPropertyMarkup expression: {subject}. Expecting a lambda which evaluates to an Entity Model property."
                          );
            }

            return(Markup.RenderPropertyAttributes(entityModel, memberExpression.Member, index));
        }
Beispiel #3
0
 /// <summary>
 /// Generates semantic markup (HTML/RDFa attributes) for a given property of a given Entity Model.
 /// </summary>
 /// <param name="htmlHelper">The HtmlHelper instance on which the extension method operates.</param>
 /// <param name="entity">The Entity Model.</param>
 /// <param name="propertyName">The name of the property.</param>
 /// <param name="index">The index of the property value (for multi-value properties).</param>
 /// <returns>The semantic markup (HTML/RDFa attributes).</returns>
 public static MvcHtmlString DxaPropertyMarkup(this HtmlHelper htmlHelper, EntityModel entity, string propertyName, int index = 0)
 {
     return(Markup.RenderPropertyAttributes(entity, propertyName, index));
 }
Beispiel #4
0
 /// <summary>
 /// Generates semantic markup (HTML/RDFa attributes) for a given property of the current Entity Model.
 /// </summary>
 /// <param name="htmlHelper">The HtmlHelper instance on which the extension method operates.</param>
 /// <param name="propertyName">The name of the property.</param>
 /// <param name="index">The index of the property value (for multi-value properties).</param>
 /// <returns>The semantic markup (HTML/RDFa attributes).</returns>
 public static MvcHtmlString DxaPropertyMarkup(this HtmlHelper htmlHelper, string propertyName, int index = 0)
 => Markup.RenderPropertyAttributes((EntityModel)htmlHelper.ViewData.Model, propertyName, index);