FileSharedPersonalizationProvider

Thursday, March 10, 2005

Looking at the provider model of ASP.NET 2.0, I thought it would be nice to write my own PersonalizationProvider. Just to see how it all works.

The WebPart framework in ASP.NET 2.0 uses a PersonalizationProvider to read and store it's WebPart data (i.e. information about the webparts on a page). WebParts can be added for SharedScope (for all users) and UserScope (per user). Because I'm only interested in the SharedScope WebParts, I thought it would be a good idea to store this SharedScope information somewhere on the filesystem, and not in a database (like the default PersonalizationProviders do).

Even better: why not store the SharedScope pagesettings inside the .aspx file itself, as a Base64 encoded string in the 'Description' attribute of the <%@ page %> directive! An .aspx page containing SharedScope PageSettings would then look something like this:

By reading the SharedScope PageSettings from the .aspx page itself, no database interaction is needed! Also, the PageSettings can be put in Cache, with a dependancy to the .aspx file itself. So by writing new PageSettings to the .aspx page, the Cached PageSettings are invalidated automatically.

To use the FileSharedPersonalizationProvider, configure it in the web.config like this:

And here's the source code for the FileSharedPersonalizationProvider. Note that my FileSharedPersonalizationProvider:

doesn't load or save UserScope pagesettings,
throws errors when the impersonated user has no rights to write the .aspx page
doesn't use a lock for reading and writing files

But besides that, it works just fine :)

using System;
using System.Web;
using System.Web.UI.WebControls.WebParts;
using System.Web.Hosting;
using System.IO;
using System.Text.RegularExpressions;

public class FileSharedPersonalizationProvider : PersonalizationProvider
{
  private const string ENCODED_PAGESETTINGS_TAG = "PageSettings";

// Loads the (shared) personalization blob from an aspx file.
  // The blob is stored as Base64 encoded string inside the 'Description' attribute 
  //  of the page directive.
  // NOTE: only Shared-scope personalization is loaded
  protected override void LoadPersonalizationBlobs(
    WebPartManager webPartManager, 
    string path, 
    string userName, 
    ref byte[] sharedDataBlob, 
    ref byte[] userDataBlob)
  {
    //check if cached pagesettings exist
    object cachedPageSettings = HttpContext.Current.Cache[ENCODED_PAGESETTINGS_TAG + ":" + path];
    if (cachedPageSettings != null)
    {
      sharedDataBlob = (byte[])cachedPageSettings;
    }
    else
    {
      //read Shared-scope personalization blob from the current aspx page 
      //the blob is stored as Base64 encoded string in the 'Description' attrib 
      // of the page directive
      string fullPath = HttpContext.Current.Request.MapPath(path);
      if (File.Exists(fullPath))
      {
        string pageContent = File.ReadAll(fullPath);
        
        Regex reDescription = new Regex(string.Format(
          @"<%@\s+page.*\s+Description\s*=\s*""<{0}>([a-zA-Z0-9\+\/=]*)<\/{0}>""", 
          ENCODED_PAGESETTINGS_TAG), RegexOptions.Multiline & RegexOptions.IgnoreCase);
        
        if (reDescription.IsMatch(pageContent))
        {
          //read encoded blob and convert back to binary blob
          string encodedBlob = reDescription.Match(pageContent).Result("$1");
          sharedDataBlob = System.Convert.FromBase64String(encodedBlob);

//store in Cache (with a dependency to current aspx file)
          webPartManager.Page.Cache.Insert(ENCODED_PAGESETTINGS_TAG + ":" + path, 
          sharedDataBlob, new System.Web.Caching.CacheDependency(fullPath));
        }
      }
    }
  }

protected override void ResetPersonalizationBlob(
    WebPartManager webPartManager, 
    string path, 
    string userName)
  {
  }

// Saves the (shared) personalization blob to an aspx file.
  // The blob is stored as Base64 encoded string inside the 'Description' attribute 
  //  of the page directive.
  // NOTE: only Shared-scope personalization is saved
  protected override void SavePersonalizationBlob(
    WebPartManager webPartManager, 
    string path, 
    string userName, 
    byte[] dataBlob)
  {
    if (userName == null)
    {
      //save blob to aspx page, as Base64 encoded string in the 'Description' attribute
      // of the page directive
      string fullPath = HttpContext.Current.Request.MapPath(path);
      
      if (File.Exists(fullPath))
      {
        string pageContent = File.ReadAll(fullPath);

//convert binary blob to base64 encoded string
        string encodedBlob = System.Convert.ToBase64String(dataBlob);

//regex to match the Description attrib of the page directive
        Regex reDescription = new Regex(@"(<%@\s+page.*\s+Description\s*=\s*"")[^""]*""", 
          RegexOptions.Multiline & RegexOptions.IgnoreCase);
        
        if (reDescription.IsMatch(pageContent))
        {
          pageContent = reDescription.Replace(pageContent, 
            string.Format("$1<{0}>{1}</{0}>\"", 
            ENCODED_PAGESETTINGS_TAG, encodedBlob));
        }
        else
        {
          //regex to match only the page directive
          Regex rePage = new Regex(@"<%@\s+page\s+",
            RegexOptions.Multiline & RegexOptions.IgnoreCase);
          
          if (rePage.IsMatch(pageContent))
          {
            pageContent = rePage.Replace(pageContent, 
              string.Format("$0Description=\"<{0}>{1}</{0}>\" ", 
              ENCODED_PAGESETTINGS_TAG, encodedBlob));
          }
          else
          {
            throw new NotSupportedException("File " + fullPath
              + " doesn't contain a <%@ page %> directive.");
          }
        }
        
        //write content back to aspx file
        File.WriteAll(fullPath, pageContent);
      }
      else
      {
        throw new FileNotFoundException("File " + fullPath + " not found!");
      }
    }
  }

private string _applicationName;
  public override string ApplicationName
  {
    get
    {
      if (string.IsNullOrEmpty(_applicationName))
      {
        _applicationName = HostingEnvironment.ApplicationVirtualPath;
      }
      return _applicationName;
    }
    set
    {
      _applicationName = value;
    }
  }

public override int GetCountOfState(
    PersonalizationScope scope, 
    PersonalizationStateQuery query)
  {
    return 0;
  }

public override PersonalizationStateInfoCollection FindState(
    PersonalizationScope scope, 
    PersonalizationStateQuery query, 
    int pageIndex, 
    int pageSize, 
    out int totalRecords)
  {
    totalRecords = 0;
    return null;
  }

public override int ResetState(
    PersonalizationScope scope, 
    string[] paths, 
    string[] usernames)
  {
    return 0;
  }

public override int ResetUserState(
    string path, 
    DateTime userInactiveSinceDate)
  {
    return 0;
  }
}

Doesn't the write on the apsx file trigger a recompile? A pure readonly version of the provider is a good idea, but a write to the page!?

Marc (obiwan-Jacobi) [Macaw] - Tuesday, March 15, 2005 8:00:00 AM

Writing to a page on a live environment is always a bad idea. The writing should be done in a 'test' environment, so the aspx files can be staged.

My example only shows a way to write the blob, so you can read it later on. Before you can read something, you must write something :)

dion - Saturday, March 19, 2005 5:43:00 AM

2 Comments