fredriktjarnberg
Aug 18, 2009
  5904
(1 votes)

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

Comments

Sep 21, 2010 10:32 AM

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)

Sep 21, 2010 10:32 AM

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.
Latest blogs
Optimizely SendGrid SMTP host is deprecated

SendGrid is a services for sending email that is included in Optimizely DXP. Previously smtp.episerver.net was the recommended SMTP server to use,...

Tomas Hensrud Gulla | Dec 4, 2022 | Syndicated blog

Hosting Optimizely CMS 12 on Docker Engine

Since Optimizely CMS can now be deployed as a Docker container, here is a demonstration of building, running and scaling an Optimizely CMS 12 site ...

Stefan Holm Olsen | Dec 4, 2022 | Syndicated blog

How to use CacheTagHelper with content areas in Optimizely CMS 12

I might be going out on a limb here - if you have a better solution, feel very free to share it!  Upgrading your Optimizely web application from .N...

Andreas J | Dec 2, 2022

The 1001st Piece in your 1000 Piece Puzzle: .NET Default Interface Functions

I was recently working with a client who wanted a reasonably large subsystem added to Optimizely that would add automated management to their...

Greg J | Nov 28, 2022 | Syndicated blog

Video Demonstration, creating a CMS12 Alloy Sample Site

Hey All Below you will find a quick video demonstration on how to install a local version of Alloy Sample based on CMS12 / .Net 6. As you will see ...

Minesh Shah (Netcel) | Nov 28, 2022

How to create an admin user I Optimizely CMS – with Episerver CLI

In this blog post I’ll show how to create an admin user for Optimizely CMS in a new environment where you don’t have access to the admin interface.

Ove Lartelius | Nov 28, 2022 | Syndicated blog