Views: 5663
Number of votes: 1
Average rating:

The lost EPiServer.TypedPageBase<PageData>

When CMS 5 R2 SP2 was in RC, it included a type to simplify using your own PageData types when building page templates. Before the release we decided to remove this class for two reasons: naming and whether or not it is OK to hide the CurrentPage property of PageBase (I think it is, btw).

What should you do if you need this type in your EPiServer project?

For those using the PageTypeBuilder project there is a replacement that should be used instead, TemplatePageBase.

However, if you for some reason still want to use the original TypedPageBase here’s the code.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EPiServer.Core;
using EPiServer.Web.PageExtensions;

namespace EPiServer
{
    /// <summary>
    /// Page Template class for supporting strongly typed PageData objects with an arbitrary type <typeparamref name="TPageData"/>.
    /// </summary>
    /// <typeparam name="TPageData">The strongly typed PageData type.</typeparam>
    public class TypedPageBase<TPageData> : PageBase
        where TPageData : PageData, new()
    {
        /// <summary>
        /// Creates a new instance of <see cref="TypedPageBase"/> with a default set of features enabled.
        /// </summary>
        public TypedPageBase() : this(
            SiteRedirect.OptionFlag | 
            ContextMenu.OptionFlag | 
            PageStatistics.OptionFlag | 
            SaveCurrentPage.OptionFlag, 0) { }

        /// <summary>
        /// Creates a new instance of <see cref="TypedPageBase"/> where individual features can be enabled and disabled.
        /// </summary>
        /// <param name="enable">The bitmask for enabling certain features.</param>
        /// <param name="disable">The bitmask for disabling certain features.</param>
        public TypedPageBase(int enable, int disable) : base(enable, disable) { }

        private TPageData _currentPage;
        /// <summary>
        /// Gets a strongly typed PageData of type <typeparamref name="TPageData"/>.
        /// </summary>
        public virtual TPageData CurrentTypedPage
        {
            get
            {
                if (_currentPage == null)
                {
                    _currentPage = PageData.ShallowCopy<TPageData>(base.CurrentPage);
                }
                return _currentPage;
            }
        }
    }
}

In the latest version of Page Type Tool the corresponding generated code looks like this:

    /// <summary>
    /// A base class for page template implementations.
    /// </summary>
    /// <typeparam name="TPageData">A PageData class that will represent the content class for the page template.</typeparam>
    public class PageBase<TPageData> : EPiServer.PageBase
        where TPageData : EPiServer.Core.PageData, new ()
    {
        private TPageData _currentPage;
        /// <summary>
        /// Creates an instance of the PageBase type.
        /// </summary>
        public PageBase() : 
                this((EPiServer.Web.PageExtensions.SiteRedirect.OptionFlag 
                                | (EPiServer.Web.PageExtensions.ContextMenu.OptionFlag 
                                | (EPiServer.Web.PageExtensions.PageStatistics.OptionFlag | EPiServer.Web.PageExtensions.SaveCurrentPage.OptionFlag))), 0)
        {
        }
        /// <summary>
        /// Creates an instance of the PageBase type with specified page feature configuration.
        /// </summary>
        /// <param name="enable">The page options to enable.</param>
        /// <param name="disable">The page options to disable.</param>
        public PageBase(int enable, int disable) : 
                base(enable, disable)
        {
        }
        /// <summary>
        /// Gets page data for the current page.
        /// </summary>
        public new virtual TPageData CurrentPage
        {
            get
            {
                if ((this._currentPage == null))
                {
                    this._currentPage = EPiServer.Core.PageData.ShallowCopy<TPageData>(base.CurrentPage);
                }
                return this._currentPage;
            }
        }
    }
The most notable difference is the type name and that it hides the CurrentPage property implementation of the base class.
Aug 18, 2009

Guest
(By Guest, 9/21/2010 12:32:36 PM)

Hey Fredrik!
I'm not familiar with what the option constructor parameter does exactly. Is the options you are using (SiteRedirect.OptionFlag | ContextMenu.OptionFlag | PageStatistics.OptionFlag | SaveCurrentPage.OptionFlag) the combination you would recommend for Page Type Builders TemplatePage/EditPage/etc classes aswell?
/ Joel Abrahamsson (joel.abrahamsson@nansen.se)

fredrik.tjarnberg
(By fredrik.tjarnberg, 9/21/2010 12:32:36 PM)

The options passed in the default constructor matches the options used for TemplatePage (which can be visualized with your favourite disassembler). So in essence using those parameters you will have the same functionality as provided by TemplatePage without the need to inherit the whole hierarchy. If you study the inheritance in detail you will find that EditPage adds a few APIs for working with script and css files which you will loose by using the PageBase implementation shown above.

The idea was to have one "small" class that provides the generic extension to PageBase instead of four.

Please login to comment.