DataGrid ItemCommand Without ViewState

using System;

namespace Controls
{
  /// <summary>
  /// Inherit the ASP.NET DataGrid
  /// </summary>
  public class DataGrid : System.Web.UI.WebControls.DataGrid
  {
    // Use these to get data from the forms collection
    private const string _EventTarget = "__EVENTTARGET";
    private const string _EventArgument = "__EVENTARGUMENT";

    /// <summary>
    /// Constuctor for the custom data grid
    /// </summary>
    public DataGrid()
    {
      // Wire up the Load & PreRender event handlers
      this.Load += new EventHandler(DataGrid_Load);
      this.PreRender += new EventHandler(DataGrid_PreRender);
    }
  }
}

/// <summary>
/// PreRender event handler
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DataGrid_PreRender(object sender, EventArgs e)
{
    // If viewstate is turned off, then we need to persist any
    // commands inside the grid
    // We need to look all the way up to the page to make
  // sure that we don't have a parent with viewstate
  // turned off even though ours is turned on
    if (!IsUsingViewState())
        PersistCommands(this);
}

/// <summary>
/// Determine if we get to use viewstate
/// </summary>
private bool IsUsingViewState()
{
    System.Web.UI.Control Control = this;

    // We need to look all the way up to the page to make
  // sure that we don't have a parent with viewstate
  // turned off even though ours is turned on
    while (Control != null && Control.EnableViewState)
        Control = Control.Parent;

  bool UsingViewState = true;

    // If we found a parent with viewstate turned off, we
  // have stopped searching and we need to persist any
  // commands inside ourself
    if (Control != null && !Control.EnableViewState)
        UsingViewState = false;

  // Let's store a flag in viewstate.  This allows us to know
  // for sure whether we rendered with viewstate or not.
  this.ViewState["DataGrid.IsUsingViewState"] = UsingViewState;

    return UsingViewState;
}

/// <summary>
/// Check to see if we were using viewstate on the
/// previous render
/// </summary>
/// <returns></returns>
private bool WasUsingViewState()
{
  // If we don't have the flag in viewstate, then we can assume
  // that we don't have viewstate
  if (this.ViewState["DataGrid.IsUsingViewState"] == null)
    return false;
  else
    return Convert.ToBoolean(
      this.ViewState["DataGrid.IsUsingViewState"]);
}

/// <summary>
/// Persist any commands inside LinkButtons -- Recursive method
/// </summary>
/// <param name="Parent"></param>
private void PersistCommands(System.Web.UI.Control Parent)
{
  bool LinkButtonFound = false;

  // Search all child controls for LinkButtons
  foreach (System.Web.UI.Control Child in Parent.Controls)
  {
    if (!LinkButtonFound
      && Child is System.Web.UI.WebControls.LinkButton)
    {
      // We found a LinkButton, let's take over the
      // rendering of the LinkButton's parent.  We have
      // to take over rendering at the parent level
      // because the RenderMethod is only called when
      // the control has its own children.  We can't
      // assume that the LinkButton will have children,
      // but we know that the LinkButton is a child of
      // its parent.  So we can safely take over rendering
      // of the current Parent.
      System.Web.UI.WebControls.LinkButton Link = 
        (System.Web.UI.WebControls.LinkButton)Child;

      Parent.SetRenderMethodDelegate(
        new System.Web.UI.RenderMethod(
          LinkButtonParentRenderer));

      // We don't need to check any more controls within
      // this parent, because the parent is already set
      // to use the custom renderer
      LinkButtonFound = true;
    }

    // Process any grandchild controls -- recursive call
    PersistCommands(Child);
  }
}

protected virtual void RenderChildren(HtmlTextWriter writer)
{
  if (this._renderMethod != null)
  {
    this._renderMethod(writer, this);
  }
  else if (this._controls != null)
  {
    int num1 = this._controls.Count;
    for (int num2 = 0; num2 < num1; num2++)
    {
      this._controls[num2].RenderControl(writer);
    }
  }
}

/// <summary>
/// This is our custom renderer for link button parents
/// </summary>
/// <param name="writer"></param>
/// <param name="Parent"></param>
private void LinkButtonParentRenderer(
  System.Web.UI.HtmlTextWriter writer,
  System.Web.UI.Control Parent)
{
  // Loop through all of the controls in the Parent.
  // We know that we'll hit at least one LinkButton
  foreach (System.Web.UI.Control Child in Parent.Controls)
  {
    // Is this our LinkButton?
    if (Child is System.Web.UI.WebControls.LinkButton)
    {
      // We found a LinkButton.  We need to override
      // his rendering so that we can set up a custom
      // Href attribute, overriding what the LinkButton
      // would have done by default
      System.Web.UI.WebControls.LinkButton Link = 
        (System.Web.UI.WebControls.LinkButton)Child;

      // Get the custom PostBack Link to use on the tag
      // and add it as the Href attribute
      writer.AddAttribute(
        System.Web.UI.HtmlTextWriterAttribute.Href,
        GetPostBackLink(Link));

      // Call the LinkButton's RenderBeginTag routine
      // to open his tag
      Link.RenderBeginTag(writer);
  
      // If the LinkButton has controls, we need to render
      // them.  From: System.Web.UI.Control.RenderChildren
      if (Link.HasControls())
      {
        // Make sure the controls collection exists
        if (Link.Controls != null)
        {
          // Render each child control
          foreach (System.Web.UI.Control LinkChild
                      in Link.Controls)
          {
            LinkChild.RenderControl(writer);
          }
        }
      }
      else
      {
        // The LinkButton didn't have any child controls,
        // so just render his text
        writer.Write(Link.Text);
      }

      // Close the tag
      Link.RenderEndTag(writer);
    }
    else
    {
      // This wasn't a LinkButton, so just
      // render him normally
      Child.RenderControl(writer);
    }
  }
}

/// <summary>
/// Get a modified PostBack client hyperlink with the
/// command name and the command argument embedded
/// </summary>
/// <param name="Link"></param>
/// <returns></returns>
private string GetPostBackLink(
  System.Web.UI.WebControls.LinkButton Link)
{
  // Get a standard postback hyperlink
  string PostBack = this.Page.GetPostBackClientHyperlink(Link,
    Link.CommandArgument);

  // Mimic Control.UniqueIDWithDollars so that we can
  // manipulate the EventTarget portion of the hyperlink.
  // Control.UniqueIDWithDollars is used by
  // GetPostBackClientHyperlink to get the EventTarget
  string UniqueIDWithDollars = Link.UniqueID;

  if (UniqueIDWithDollars != null
    && UniqueIDWithDollars.IndexOf(':') >= 0)
    UniqueIDWithDollars =
      UniqueIDWithDollars.Replace(':', '$');

  // Add the CommandName onto the EventTarget,
  // using '=' to designate it
  return PostBack.Replace(
    UniqueIDWithDollars,
    UniqueIDWithDollars + '=' + Link.CommandName);
}

    javascript:__doPostBack('dgGrid$_ctl2$_ctl0=Edit','1')

/// <summary>
/// On Load, search for any events we need to fire if
/// viewstate was disabled last render
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DataGrid_Load(object sender, EventArgs e)
{
  // We only care about postbacks when we didn't have
  // viewstate on the previous render
  if (Page.IsPostBack && !WasUsingViewState())
  {
    // The page is posting back and we didn't have
    // viewstate.  Get the event target of the postback
    string EventTarget =
      this.Page.Request.Form[_EventTarget];

    // If the event target starts with our ID then we
    // know that we fired the postback
    if (EventTarget != null
      && EventTarget.StartsWith(this.ClientID))
    {
      // Get the command name from the event target and
      // the command argument from event argument
      string CommandName = GetCommandName(EventTarget);
      string CommandArgument =
        this.Page.Request.Form[_EventArgument];

      // Fire the bubble event, which will handle
      // sort commands, edit commands, etc.
      this.OnBubbleEvent(this, new
        System.Web.UI.WebControls.DataGridCommandEventArgs(
        null, this,new
        System.Web.UI.WebControls.CommandEventArgs(
        CommandName, CommandArgument)));
    }
  }
}

/// <summary>
/// Get the command name from the event target value
/// </summary>
/// <param name="EventTarget"></param>
/// <returns></returns>
private string GetCommandName(string EventTarget)
{
  // Make sure that we have our designator to identify
  // our command name
  if (EventTarget.IndexOf('=') > 0)
    return EventTarget.Substring(EventTarget.IndexOf('=') + 1);
  else
    return null;
}