.Net Diary

MyRenderingPlaceHolder class

    public class MyRenderingPlaceHolder : WebControl
    {
        public event EventHandler BeginRender;

        public MyRenderingPlaceHolder()
            : base()
        {
        }

        protected override void Render(HtmlTextWriter writer)
        {
            OnBeginRender(null);
        }

        protected virtual void OnBeginRender(EventArgs e)
        {
            if (BeginRender != null)
            {
                BeginRender(this, e);
            }
        }
    }

MyForm class

    public class MyForm : HtmlForm
    {
        private HtmlTextWriter _htmlWriter;
        private System.IO.TextWriter _savedInnerWriter;
        private StringBuilder _viewStateBuilder;

        public MyForm() : base()
        {
        }

        protected override void RenderChildren(HtmlTextWriter writer)
        {
            _viewStateBuilder = new StringBuilder();

            using (System.IO.StringWriter viewStateWriter = new System.IO.StringWriter(_viewStateBuilder))
            {
                _htmlWriter = writer;
                _savedInnerWriter = writer.InnerWriter;

                writer.InnerWriter = viewStateWriter;

                base.RenderChildren(writer);
               
                viewStateWriter.Close();
            }
        }

        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);

            MyRenderingPlaceHolder renderingPlaceHolder = new MyRenderingPlaceHolder();

            renderingPlaceHolder.ID = "FirstChild";
            renderingPlaceHolder.BeginRender += new EventHandler(FirstChild_BeginRender);
            renderingPlaceHolder.EnableViewState = false;

            Controls.AddAt(0, renderingPlaceHolder);
        }

        protected override void OnPreRender(EventArgs e)
        {
            // Register a rendering placeholder as the last child so we can switch the writer back before
            // any scripts / html written by page.EndFormRender(writer, this.UniqueID) and page.OnFormPostRender();
            // occurs.  This ensures we preserve the order of javascript which otherwise fails for Callbacks due to 
            // undeclared variables...

            base.OnPreRender(e);

            MyRenderingPlaceHolder renderingPlaceHolder = new MyRenderingPlaceHolder();

            renderingPlaceHolder.ID = "LastChild";
            renderingPlaceHolder.BeginRender += new EventHandler(LastChild_BeginRender);
            renderingPlaceHolder.EnableViewState = false;

            Controls.Add(renderingPlaceHolder);
        }

        private void FirstChild_BeginRender(object sender, EventArgs e)
        {
            _htmlWriter.InnerWriter = _savedInnerWriter;
        }

        private void LastChild_BeginRender(object sender, EventArgs e)
        {
            // Write the viewstate before the Page.EndFormRender and Page.OnFormPostRender code executes so that
            // we maintain javascript order etc..
            _htmlWriter.Write(_viewStateBuilder.ToString());
        }
    }

AJAX ScriptManager Problem

1. Add this function to the MyForm control.

        private MyRenderingPlaceHolder GetViewStateRenderingPlaceholder()
        {
            foreach (Control candidate in Controls)
            {
                if (candidate.ID != null && candidate.ID.Equals("ViewStatePlaceHolder") && candidate is MyRenderingPlaceHolder)
                {
                    return (MyRenderingPlaceHolder)candidate;
                }
            }

            return null;
        }

2. Replace MyForm.OnPreRender with the following code:

        protected override void OnPreRender(EventArgs e)
        {
            base.OnPreRender(e);

            MyRenderingPlaceHolder renderingPlaceHolder = GetViewStateRenderingPlaceholder();

            if (renderingPlaceHolder == null)
            {
                renderingPlaceHolder = new MyRenderingPlaceHolder();

                renderingPlaceHolder.ID = "ViewStatePlaceHolder";
                renderingPlaceHolder.BeginRender += new EventHandler(ViewStatePlaceHolder_BeginRender);
                renderingPlaceHolder.EnableViewState = false;

                Controls.Add(renderingPlaceHolder);
            }
            else
            {
                renderingPlaceHolder.BeginRender += new EventHandler(ViewStatePlaceHolder_BeginRender);
            }
        }

3. Rename LastChild_BeginRender event to ViewStatePlaceHolder_BeginRender

        private void ViewStatePlaceHolder_BeginRender(object sender, EventArgs e)
        {
            // Write the viewstate before the Page.EndFormRender and Page.OnFormPostRender code executes so that
            // we maintain javascript order etc..
            _htmlWriter.Write(_viewStateBuilder.ToString());
        }

Include the rendering placeholder on your Page

    <sug:MyForm ID="form1" runat="server">
    <div>
        <!-- Put your non script-include sensitive controls here -->
        
        <sug:MyRenderingPlaceHolder ID="ViewStatePlaceHolder" runat="server" />        
                
        <asp:ScriptManager ID="ScriptManager1" runat="server">
        </asp:ScriptManager>               
    </div>
    </sug:MyForm>

Labels: ASP.NET, Moving ViewState Field

// posted by David Sugden @ 22:13 4 Comments

I've recently been writing an email subscription application for one of our e-commerce sites and re-used a pattern that I developed a couple of years ago. I thought it might be worth sharing to see if anyone else is doing anything similar...

I want a C# enum with a string or character value. In otherwords, I want to do something like:

enum Status : string
{
   Active = "A",
   PendingActivation = "P",
   Deleted = "D"
   ...
}

In my application I want to use the nice friendly enum constants e.g. "Status.Active", but in my database I'm optimising and only want to store a single character to represent each state. I also want a centralised point where I convert to/from the value so that if I add or change states I only have one place to change the code. Finally, I need to be able to compare instances of the enum for equality, e.g. If (Subscription.Status == Status.PendingActivation).

I guess some of the database folks out there will say that I should have a new database table "STATUS" and have records in it for each possible status and then use the STATUS record's ID elsewhere in the database. May'be, but to be honest sometimes that is total overkill. Sometimes, I just want a simple flag column that happens to have more than two states (e.g. true or false) and so I cannot use a boolean.

Unfortunately, string enum values are not supported in C#, so I decided to develop a "pseudo enum" class that worked like an enum but with string values...

Firstly, since I'm going to need more than one of these types I created a base class to do most of the work:

    public abstract class EnumObject
    {
        private string _caption;
        private string _value;

        protected EnumObject()
        {
        }

        protected EnumObject(string caption, string theValue)
            : base()
        {
            _caption = caption;
            _value = theValue;
        }

        public string Caption
        {
            get { return _caption; }
            set { _caption = value; }
        }

        public string Value
        {
            get { return _value; }
            set { _value = value; }
        }

        public static bool operator ==(EnumObject a, EnumObject b)
        {
            if ((object)a == null && (object)b == null)
            {
                return true;
            }
            else if ((object)a == null || (object)b == null)
            {
                return false;
            }

            return a.Value == b.Value;
        }

        public static bool operator !=(EnumObject a, EnumObject b)
        {
            return !(a == b);
        }

        public override bool Equals(object b)
        {
            if (b is EnumObject)
            {
                return (this == (EnumObject)b);
            }
            else
            {
                return false;
            }
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }

Note: if you don't need to support XML serialization you can remove the parameterless constructor and the SET operations from the Value and Caption properties.

This base class gives us a basic Caption + Value pair and the ability to compare instances based on their Value.

Now to define a pseudo-enum we need to define a new class that inherits from EnumObject. The example below defines a new "enum" called SubscriptionStatus with two constants - "PendingActivation" and "Active". In C# if strings were supported as enum values it might look like this...

enum SubscriptionStatus : string
{
   Active = "A",
   PendingActivation = "P"
}

You will notice in the code below, for each enum constant we define a static property that returns an instance of our new type prepopulated with the appropriate Caption and Value. Since this is a fully fledged class we can also add other useful behaviour like a static Create() method that returns an instance of the enum based on a Value. This is useful when we need to read a Value from the database and turn it into an instance of the enum class. It achieves my objective of centralising the translation code.

    public class SubscriptionStatus : EnumObject 
    {
        public SubscriptionStatus()
            : base()
        {
        }

        private SubscriptionStatus(string caption, string theValue)
            : base(caption, theValue)
        {
        }
        
        public static SubscriptionStatus PendingActivation
        {
            get { return new SubscriptionStatus("PendingActivation", "P"); }
        }

        public static SubscriptionStatus Active
        {
            get { return new SubscriptionStatus("Active", "A"); }
        }

 // Add more enum constants here...

        public static SubscriptionStatus Create(string code)
        {
            switch (code.ToUpper())
            {
                case "P":
                    return PendingActivation;

                case "A":
                    return Active;

                default:
                    throw new ArgumentException("Invalid status code:" + code);
            }
        }
    }

Finally, when we want to write the Value to the database we can simple pass the .Value property of the enum instance. For example, mySubscription.Status.Value.

So thats my enum object pattern, let me know what you think or if you have any improvements.

Labels: ASP.NET, C# enum, enum class

// posted by David Sugden @ 08:49 0 Comments

Breaking news...Fix for ICallbackEventHandler available!

1. ASP.NET Renders the form contents by calling the Form.RenderChildren method
2. The Form control calls Page.BeginFormRender
3. The Page BeginFormRender() method writes out the ViewState and other control fields
4. The Form control renders its children

The obvious solution was to move the call to Page.BeginFormRender to after the forms child controls had been rendered (i.e. switch steps 2 & 4). Wilco points to this solution too. Unfortunately, we cannot easily do that because Page.BeginFormRender is declared as internal so we can't call it directly. Also we would have to duplicate the original Form.RenderChildren code to allow us to tweak the ordering and as stated I don't like doing this as it creates a big code dependency. What happens when someone at Microsoft changes that method, suddenly my code breaks or something stops working! What I needed to do was to allow ASP.NET to do it's stuff as normal, but to somehow intercept its output so I could move it in it's entirety later. This is exactly what I ended up doing...

My Solution: Using A Custom Form and Placeholder Control

OK so this is my solution, let me know what you think. If you've posted this somewhere already and I've missed it I apologise.

If you look back at the problem what we really want to do is to is to split the Form.RenderChildren method into the piece that happens before the forms "real" children start getting rendered (i.e. when ViewState et al are written) and the piece where the "real" children are being rendered. We then want to swap the order of the two pieces. I acheived this by swapping in a surrogate StringWriter as the HtmlTextWriter.InnerWriter for ASP.NET to write to, which I then swap back to the original HttpWriter before the children are rendered. Then after the children are rendered I write the content of the surrogate StringWriter to the HtmlTextWriter before the form tag is closed. The key is having a control that notifies us when the rendering of the forms "real" children has started so we can do the switch back. I do this by using a placeholder control inserted at position 0 in the control collection. This placeholder raises an event in it's render method to signal that the switch back needs to occur. The code is included below...

1. Create a new WebControl called MyRenderingPlaceHolder. Override its Render method and raise the BeginRender event when it is called. Do not call base.Render() as we don't want any HTML to be written out for this control.

public class MyRenderingPlaceHolder : WebControl
{
public event EventHandler BeginRender;
public MyRenderingPlaceHolder() : base()
{
}
protected override void Render(HtmlTextWriter writer)
{
OnBeginRender(null);
}
protected virtual void OnBeginRender(EventArgs e)
{
if (BeginRender != null)
{
BeginRender(this, e);
}
}
}

2. Create your own Form control that inherits from HTMLForm called MyForm

public class MyForm : HtmlForm
{
private HtmlTextWriter _htmlWriter;
private System.IO.TextWriter _savedInnerWriter;

3. In your MyForm control override the OnInit method. Create a MyRenderingPlaceHolder control and add it as the first control in the collection. Register for the MyRenderingPlaceHolder.BeginRender event. Don't forget to call base.OnInit.

protected override void OnInit(EventArgs e)
{
base.OnInit(e);
MyRenderingPlaceHolder renderingPlaceHolder = new MyRenderingPlaceHolder();
renderingPlaceHolder.ID = "FirstChild";
renderingPlaceHolder.BeginRender += new EventHandler(FirstChild_BeginRender);
renderingPlaceHolder.EnableViewState = false;
Controls.AddAt(0, renderingPlaceHolder);
}

4. In MyForm override the RenderChildren method and subsitute the writer.InnerWriter for your own StringWriter instance (viewStateWriter). Keep the original HttpWriter to switch back to later, then call base.RenderChildren. After the call to base.RenderChildren write the contents of viewStateWriter to the HtmlTextWriter. By the time we reach this point the switch back will have occurred and we are now effectively writing the ViewState et al to the HttpWriter.

protected override void RenderChildren(HtmlTextWriter writer)
{
using (System.IO.StringWriter viewStateWriter = new System.IO.StringWriter())
{
_htmlWriter = writer;
_savedInnerWriter = writer.InnerWriter;
writer.InnerWriter = viewStateWriter;
base.RenderChildren(writer);
writer.Write(viewStateWriter.ToString());
viewStateWriter.Close();
}
}

5. In the MyForm handler for MyRenderingPlaceHolder.BeginRender event swap the writer.InnerWriter back to the original one we swapped out earlier. The subsequent child controls will now be rendered to the HttpWriter and underlying response stream.

private void FirstChild_BeginRender(object sender, EventArgs e)
{
_htmlWriter.InnerWriter = _savedInnerWriter;
}

To get viewstate moved on a page all you need to do is subsitute the MyForm control for the standard HTMLForm control on your aspx pages.

<mycontrols:myform id="form1" runat="server">

The main benefit of this solution is that it doesn't make any assumption about what "control" fields ASP.NET is going to write out or how the HTML for them is going to look. It also moves the whole lot to the end of the form and will automatically cope with any changes to that part of ASP.NET. Finally, it also does not rely on duplicating critical chunks of the existing HTML forms behavour and therefore has very few dependencies that might cause it to stop working in the future.

So that's it. I don't think my solution breaks anything, but if you find otherwise then let me know. Don't forget that when you move the ViewState you introduce the issue that you could get a viewstate exception if a user causes a form post before the ViewState field has rendered in the browser. However, as long as you keep your pages "light" (e.g. avoid using ViewState unnecessarily) and server response times low then this should not be a problem.

Anyway, hopefully I've managed to explain it well enough. Let me know what you think or if you have a better way.

Labels: ASP.NET, Moving ViewState Field

// posted by David Sugden @ 10:18 3 Comments