The Page Appearance Framework.

crisag — Tue, 03 Oct 2006 22:37:00 GMT

Are you curious on how to control the appearance of an ASP .Net pages using design time properties? Guys from Commerce Server team have shown how to deal with this problem. On a preliminary version of the CS2007 Starter Site (that one with came with CS2007 Beta) they use class properties to deal with the appearance of the sample store page framework.

First step is create a new masterpage with a set of DIV files that can be enabled or disabled according with different page layout statuses.

The second step is create a base class with a property to control the presentation

public abstract class SiteMasterPage : System.Web.UI.MasterPage
{
}

• Layout property: Control the appearance of the DIV areas inside the masterpage. Depending on context, the background code can change the layout of the page.

Now you need to create a new masterpage and insert code to deal with the properties:

• OnPreRender event: Deal with layout. Activating or deactivating DIVs according to the Layout properties

protected override void OnPreRender(EventArgs e)
{
switch (this.LayoutStyle)
   {
  //se for mínimo, remove o banner, os sidebars, o menu e o rodapé.
            // deixa só o mainpagecontent
            case PageLayoutStyle.Minimal:
                this.adbanner.Visible = false;
                this.sidebar_a.Visible = false;
                this.sidebar_b.Visible = false;
                this.footer.Visible = false;
                this.menu.Visible = false;
                break;
  case PageLayoutStyle.Full:
      this.adbanner.Visible = true;
                this.sidebar_a.Visible = true;
                this.sidebar_b.Visible = true;
                this.footer.Visible = true;
                this.menu.Visible = true;
                break;
            }

base.Page.Title = this.title; //ajusta o título da página
base.OnPreRender(e); //executa a base do prerender
}

To get the design time class properties you can use a piece of code like the following one:

settings = PageSettings.GetPageSettings(HttpContext.Current.CurrentHandler.GetType());

internal static PageSettings GetPageSettings(Type type)
{
    if (type == null)
    {
        throw new ArgumentNullException("type");
    }
    if (!type.IsSubclassOf(typeof(Page)))
    {
        throw new ArgumentException("SubClass", "type");
    }
    if (!PageSettings.typeCache.ContainsKey(type))
    {
        lock(typeCache)
        {
            // Não está em cache, temos que popular.
            if (!PageSettings.typeCache.ContainsKey(type))
            {
                string pageGroup = null;
                bool isSecure = false;
                PageLayoutStyle layoutStyle = PageLayoutStyle.Full;
                object[] attributes = type.GetCustomAttributes(true);
                foreach (Attribute attribute in attributes)
                {
                    if (typeof(PageLayoutAttribute).IsInstanceOfType(attribute))
                    {
                        layoutStyle = ((PageLayoutAttribute)attribute).LayoutStyle;
                    }
                }
                PageSettings.typeCache.Add(type, new PageSettings(layoutStyle, isSecure, pageGroup));
            }
        }

}
return PageSettings.typeCache[type];
}

At design time, we just need to tell how the page will look using the following approach:

[PageLayout(PageLayoutStyle.Full)]
public partial class _Default : System.Web.UI.Page
{
…
}

Remember that your ASPX page must be based on a MasterPage created from the custom base class.

public partial class StandardLayout : SiteMasterPage
{
...
}

Regards, Cris.

This posting is provided "AS IS" with no warranties, and confers no rights.

The Visual Studio 2005 Code-Beside Dilemma!

crisag — Fri, 29 Sep 2006 16:50:00 GMT

Did you know that? With Visual Studio 2003 we were able to extend the System.Web.UI.Page class and create new properties for WebForms. Test yourself, using VS2003, create a new property for your class (derived from System.Web.UI.Page), create a new ASP .Net page based on your new class and you will see the created property it on the Visual Studio properties page for the ASPX.

When saving the page, you will see that the code behind is automatically changed to include the property values. It is a very easy approach to create custom properties on ASP .Net web pages.

A couple of weeks ago I was working with one of our customers and I said that he could use the properties approach to easily customize the appearance of his ASP .Net web pages. But what’s my surprise when I noticed that this is not working on Visual Studio 2005.

Ok. Know the reason for such thing not work anymore became a question of honor. After post some questions on our internal lists and search a little bit on the Internet I figured out the reason.

Before begin the explanation, I’d like to let you know that it is a known issue reported at http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=105510.

Let’s try to explain.

According to my research there was a design change in the product. Basically in Visual Studio 2005 RTM, the code behind file and the generated stub are compiled into the base class, and the actual ASP .Net page inherits the base class.

The V1.X code behind model (seen on the Visual Studio 2003) is still supported by the runtime, however, you cannot use Visual Studio 2005 for editing the V1.X style pages.

The code that was being generated by Visual Studio 2003 IDE is now moved to the partial class that is automatically generated during compilation. If you just want to see what is in the generated class, you can set the page to debug mode and look for the generated files under the ASP.NET temporary folder.

The model is changed to allow updatable pages after compilation. To achieve this, the product group came up with the current model which is very similar to V1.X that the codes behind files are still compiled into the base classes. The only difference is that the control field declarations and the class constructor are now automatically generated instead of injected at design time.

So the collateral effect appeared. As the control field declarations are automatically generated at the compilation time we cannot store the adjusted values for custom properties on the appropriate place. Therefore we need a different approach to implement this kind of functionality.

I managed to implement (with the help of a sort of samples) a mechanism that can be used to coordinate the appearance of ASP .Net pages at design time using class properties injected manually on the code. I’ll show how to do that on another post. Stay tuned!

Bye!!

This posting is provided "AS IS" with no warranties, and confers no rights.

Cristiano WebLog : Visual Studio 2005

The Page Appearance Framework.

The Visual Studio 2005 Code-Beside Dilemma!