This fix applies to legacy ASP.NET Web Forms or ASP.NET MVC applications running on .NET Framework and using DotNetOpenAuth. If you are building a new application on ASP.NET Core, use the built-in external authentication providers instead of this older pattern.

Problem

I was helping a friend wire up Facebook OAuth login in an older ASP.NET application using the DotNetOpenAuth extensions installed from NuGet.

The code looked like this:

Uri ui = new Uri("~/Login.aspx", UriKind.Relative);

var fbClient = new DotNetOpenAuth.AspNet.Clients.FacebookClient("***", "***********");
fbClient.RequestAuthentication(context, ui);

The problem is that RequestAuthentication expects an instance of HttpContextBase.

If you try to pass HttpContext.Current directly, it fails because HttpContext.Current is a HttpContext, not a HttpContextBase.

Why This Happens

HttpContextBase was introduced as an abstraction over HttpContext. This makes ASP.NET code easier to test and easier to work with in components that should not depend directly on the concrete runtime context.

To bridge the gap between the two types, ASP.NET provides HttpContextWrapper.

Solution

Wrap HttpContext.Current in a HttpContextWrapper before calling RequestAuthentication:

var httpContextBase = new HttpContextWrapper(HttpContext.Current);
fbClient.RequestAuthentication(httpContextBase, ui);

Explanation

HttpContextWrapper acts as an adapter. It takes the current ASP.NET request context and exposes it as a HttpContextBase, which is exactly what the DotNetOpenAuth API expects.

So if you are maintaining a legacy ASP.NET application and run into a type mismatch between HttpContext and HttpContextBase, this wrapper is the correct fix.

Modern Note

For new applications, this is no longer the recommended approach. In modern ASP.NET Core applications, external login providers such as Facebook are configured through the built-in authentication middleware, and System.Web, HttpContextBase, and HttpContextWrapper are not part of that model.

public static string RenderViewToString(string viewName, object model) 
{
 if (string.IsNullOrEmpty(viewName)) 
     viewName = ControllerContext.RouteData.GetRequiredString("action");

 ViewData.Model = model;
 using(StringWriter sw = new StringWriter()) 
 {
  ViewEngineResult viewResult = ViewEngines.Engines.FindPartialView(ControllerContext, viewName);
  ViewContext viewContext = new ViewContext(ControllerContext, viewResult.View, ViewData, TempData, sw);
  viewResult.View.Render(viewContext, sw);
  return sw.GetStringBuilder().ToString();
 }
}

ControllerContext.RouteData.GetRequiredString("action");

public static string RenderViewToString(ControllerContext context, string viewName, object model) 
{
 if (string.IsNullOrEmpty(viewName)) 
     viewName = context.RouteData.GetRequiredString("action");
 
 var viewData = new ViewDataDictionary(model);
 using(var sw = new StringWriter()) 
 {
  var viewResult = ViewEngines.Engines.FindPartialView(context, viewName);
  var viewContext = new ViewContext(context, viewResult.View, viewData, new TempDataDictionary(), sw);
  viewResult.View.Render(viewContext, sw);
  return sw.GetStringBuilder().ToString();
 }
}

//Somewhere in HomeController
public ActionResult Index() 
{
 //Second parameter(model) can be null
 var context = ControllerContext.RouteData.GetRequiredString("action");
 var content = RenderViewToString(context, "profile", new ProfileModel());
 //var content = RenderViewToString("profile", new ProfileModel());

 
        //Do something with the content, e.g.get profile specific template and send it to e-mail


 //This does nothing to do with rendered string
 return View();
}

If you need to get the current routed page inside a block controller, view component, or action filter in Optimizely CMS, the usual approach is to use IPageRouteHelper.

If you want the current routed content more generically, use IContentRouteHelper.

Modern Approach

In newer Optimizely CMS projects, it is better to use constructor injection instead of ServiceLocator.Current.

Get the Current Page

using EPiServer.Web.Routing;

public class MyService
{
    private readonly IPageRouteHelper _pageRouteHelper;

    public MyService(IPageRouteHelper pageRouteHelper)
    {
        _pageRouteHelper = pageRouteHelper;
    }

    public PageData GetCurrentPage()
    {
        return _pageRouteHelper.Page;
    }
}

Get the Current Page Reference

using EPiServer.Web.Routing;

public class MyService
{
    private readonly IPageRouteHelper _pageRouteHelper;

    public MyService(IPageRouteHelper pageRouteHelper)
    {
        _pageRouteHelper = pageRouteHelper;
    }

    public PageReference GetCurrentPageReference()
    {
        return _pageRouteHelper.PageLink;
    }
}

Get the Current Routed Content

If you do not specifically need a page, use IContentRouteHelper instead:

using EPiServer.Web.Routing;

public class MyService
{
    private readonly IContentRouteHelper _contentRouteHelper;

    public MyService(IContentRouteHelper contentRouteHelper)
    {
        _contentRouteHelper = contentRouteHelper;
    }

    public IContent GetCurrentContent()
    {
        return _contentRouteHelper.Content;
    }

    public ContentReference GetCurrentContentReference()
    {
        return _contentRouteHelper.ContentLink;
    }
}

Using It in an Action Filter

If you need the current page inside an action filter, you can resolve the helper from the request services:

using EPiServer.Web.Routing;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.Extensions.DependencyInjection;

public class MyActionFilter : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        var pageRouteHelper = context.HttpContext.RequestServices.GetRequiredService<IPageRouteHelper>();
        var currentPage = pageRouteHelper.Page;
        var currentPageReference = pageRouteHelper.PageLink;

        base.OnActionExecuting(context);
    }
}

Legacy Example

If you are working with older code, you may still see ServiceLocator.Current being used:

using EPiServer.ServiceLocation;
using EPiServer.Web.Routing;

var pageRouteHelper = ServiceLocator.Current.GetInstance<IPageRouteHelper>();
var currentPage = pageRouteHelper.Page;
var pageReference = pageRouteHelper.PageLink;

Important Note

Page and PageLink are only available when the current request is actually routed to a page. In some non-page contexts, such as certain preview scenarios, they may be null. If you need a more general routed object, IContentRouteHelper is the safer choice.

Final Thought

If your code only needs the routed content, prefer IContentRouteHelper. If your code specifically depends on a page, use IPageRouteHelper.

Suppose your EPiServer CMS site contains a large number of pages and supports multiple languages, for example English (en), French (fr), and Italian (it).

You want to remove one language branch, such as French, from all pages across the site, but you do not know exactly how many pages currently use that language.

If you try to remove the language directly from the CMS admin UI, you will usually hit an error because the language is still being used by content or language settings.

Before You Start

• Take a database backup first.
• Test the process in a lower environment before running it in production.
• Disable the target language in Admin/Settings > Manage Website Languages so editors cannot keep creating new versions while the cleanup is running.
• This approach will not delete pages where the language you want to remove is the master language. Those must be handled separately.

Small Sites vs Large Sites

If only a handful of pages use the language, the built-in Versions gadget is usually enough.

But if the site is large, deleting language branches manually page by page quickly becomes painful. In that case, a scheduled job is the safer and more practical option.

Modern Approach

In newer EPiServer / Optimizely CMS solutions, the cleanest approach is to:

• Loop through the site start pages and their descendants.
• Check whether a page has the language branch you want to remove.
• Skip pages where that language is the master language.
• Delete the branch with IContentRepository.DeleteLanguageBranch.

Scheduled Job Example

using System;
using System.Collections.Generic;
using System.Linq;
using EPiServer;
using EPiServer.Core;
using EPiServer.PlugIn;
using EPiServer.Scheduler;
using EPiServer.Security;
using EPiServer.Web;

[ScheduledPlugIn(
    DisplayName = "Delete French Language Branch From All Pages",
    Description = "Deletes the fr branch from all pages where fr is not the master language.",
    SortIndex = 100)]
public class DeleteLanguageBranchFromAllPagesJob : ScheduledJobBase
{
    private readonly IContentLoader _contentLoader;
    private readonly IContentRepository _contentRepository;
    private readonly ISiteDefinitionRepository _siteDefinitionRepository;

    private bool _stopRequested;

    private const string LanguageToDelete = "fr";

    public DeleteLanguageBranchFromAllPagesJob(
        IContentLoader contentLoader,
        IContentRepository contentRepository,
        ISiteDefinitionRepository siteDefinitionRepository)
    {
        _contentLoader = contentLoader;
        _contentRepository = contentRepository;
        _siteDefinitionRepository = siteDefinitionRepository;

        IsStoppable = true;
    }

    public override string Execute()
    {
        var scanned = 0;
        var deleted = 0;
        var skippedMasterLanguage = 0;
        var failed = 0;
        var visited = new HashSet<int>();

        foreach (var site in _siteDefinitionRepository.List().Where(x => !ContentReference.IsNullOrEmpty(x.StartPage)))
        {
            var references = new[] { site.StartPage }.Concat(_contentLoader.GetDescendents(site.StartPage));

            foreach (var contentLink in references)
            {
                if (_stopRequested)
                {
                    return $"Stopped. Scanned: {scanned}, Deleted: {deleted}, Skipped master language: {skippedMasterLanguage}, Failed: {failed}";
                }

                if (!visited.Add(contentLink.ID))
                {
                    continue;
                }

                scanned++;

                try
                {
                    var languageBranches = _contentRepository
                        .GetLanguageBranches<IContent>(contentLink)
                        .OfType<PageData>()
                        .ToList();

                    if (!languageBranches.Any())
                    {
                        continue;
                    }

                    var branchToDelete = languageBranches.FirstOrDefault(x =>
                        string.Equals(x.Language.Name, LanguageToDelete, StringComparison.OrdinalIgnoreCase));

                    if (branchToDelete == null)
                    {
                        continue;
                    }

                    if (branchToDelete is ILocalizable localizable &&
                        localizable.MasterLanguage != null  &&
                        string.Equals(localizable.MasterLanguage.Name, LanguageToDelete, StringComparison.OrdinalIgnoreCase))
                    {
                        skippedMasterLanguage++;
                        continue;
                    }

                    _contentRepository.DeleteLanguageBranch(contentLink, LanguageToDelete, AccessLevel.Delete);
                    deleted++;
                }
                catch (Exception ex)
                {
                    failed++;
                    OnStatusChanged($"Failed for content ID {contentLink.ID}: {ex.Message}");
                }
            }
        }

        return $"Completed. Scanned: {scanned}, Deleted: {deleted}, Skipped master language: {skippedMasterLanguage}, Failed: {failed}";
    }

    public override void Stop()
    {
        _stopRequested = true;
    }
}

How It Works

The job goes through each site start page and all descendant pages beneath it. For every page, it checks whether the target language exists.

If the page contains the target branch and that branch is not the master language, the job removes it. If the target language is the master language, the page is skipped.

After the Job

• Review the skipped pages. These are typically pages where the language you want to remove is the master language.
• Try removing the language from Manage Website Languages again.
• If the CMS still reports that the language is used in language settings, clear that language from the affected start pages or content language settings and retry.

Final Note

If you only need to remove language branches from a few pages, use the UI. If you need to clean up hundreds or thousands of pages, a scheduled job like the above is a much more realistic approach.

If you also want to remove the same language from blocks or media, the same idea can be extended beyond PageData to other localizable content types.

If you want to get all page types in Optimizely CMS, the recommended modern approach is to use IContentTypeRepository.

This is the cleaner replacement for older patterns such as PageTypeRepository or PageType.List().

Modern approach

In newer Optimizely CMS projects, use IContentTypeRepository and filter the result to PageType:

using System.Linq;
using EPiServer.DataAbstraction;

var contentTypeRepository = ServiceLocator.Current.GetInstance<IContentTypeRepository>();

var pageTypes = contentTypeRepository
    .List()
    .OfType<PageType>()
    .OrderBy(x => x.DisplayName ?? x.Name)
    .ToList();

This returns the page type definitions configured in the CMS.

Recommended approach in application code

If you are writing new code, constructor injection is better than using ServiceLocator.Current:

using System.Collections.Generic;
using System.Linq;
using EPiServer.DataAbstraction;

public class PageTypeService
{
    private readonly IContentTypeRepository _contentTypeRepository;

    public PageTypeService(IContentTypeRepository contentTypeRepository)
    {
        _contentTypeRepository = contentTypeRepository;
    }

    public IList<PageType> GetAllPageTypes()
    {
        return _contentTypeRepository
            .List()
            .OfType<PageType>()
            .OrderBy(x => x.DisplayName ?? x.Name)
            .ToList();
    }
}

About PageTypeRepository

You may still see older examples using PageTypeRepository:

using EPiServer.DataAbstraction;
using EPiServer.ServiceLocation;

var repository = ServiceLocator.Current.GetInstance<PageTypeRepository>();
var pageTypes = repository.List();

This still appears in older codebases, but the official Optimizely API marks PageTypeRepository as obsolete and recommends using IContentTypeRepository instead.

Legacy fallback

For older EPiServer projects, you may still find this approach:

var pageTypes = EPiServer.DataAbstraction.PageType.List();

This method is obsolete in later versions, but it can still be useful when maintaining legacy solutions.

Final note

Remember that this gives you the list of page type definitions, not the actual pages created from those types. If you need the pages themselves, you will need to query content separately.

Large Optimizely or EPiServer projects tend to collect old page types over time. New templates are introduced, editors move on to newer content types, and some older page types quietly stop being used.

If you are cleaning up a long-running CMS solution, one of the first things worth checking is which page types are still in use and which ones have a page count of zero.

The SQL query below gives you a quick usage report for page types. It does not cover block types, but it is a useful first step when auditing legacy CMS projects.

Quick SQL Audit

Run the following query in SQL Server to list page type names, filenames, and the number of pages using each type:

SELECT
    pt.Name,
    pt.Filename,
    COUNT(p.pkID) AS PageCount
FROM tblPageType AS pt
LEFT JOIN tblPage AS p
    ON p.fkPageTypeID = pt.pkID
GROUP BY
    pt.Name,
    pt.Filename
ORDER BY
    PageCount DESC,
    pt.Name;

Why This Is Useful

This report helps you quickly spot:

• page types that are heavily used
• page types that are rarely used
• page types with a PageCount of 0, which may be candidates for cleanup

Before You Run It

Empty the recycle bin first. Deleted content can still affect the result and make unused page types look active when they are not.

Important Note

A page count of zero is a strong signal, but it should not automatically mean “safe to delete”. Before removing a page type from code, double-check whether it is still referenced by old templates, import jobs, migrations, or content type availability rules.

For older self-hosted EPiServer or Optimizely CMS solutions, this is a quick and practical way to start a cleanup exercise without building a custom report first.