2008
09/23/2008

ASP.NET Ajax, JQuery & JSON Date Serialization

A little while back I came across a great post on how to use JQuery to do more efficient client side paging by Dave Ward. The sample shows you how to use JQuery to do Ajax callbacks for client side paging using a grid template. After downloading the demo and parsing through it all, I found a lot of things I really liked and even came across a little gotchya with the way ASP.NET serializes dates in JSON.

One part I really enjoyed about this sample is that your objects on the server are translated into client side objects. So Order.OrderID or Order.ShippingAddress.ShipName would work the same on the client and server side of the programming. The jtemplates add-in allows you to name your active object of the collection you are looping through a lot like .NET like so:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<tbody>
    {#foreach $T.d as order}
    <tr>
        <td>
            {$T.order.OrderID}
        </td>
        <td>
            {$T.order.ShippingAddress.ShipName}
        </td>
        <td>
            {DateDeserialize($T.order.OrderDate).format('MM/dd/yyyy')}
        </td>
        <td>
            {DateDeserialize($T.order.RequiredDate).format('MM/dd/yyyy')}
        </td>
        <td>
            {$T.order.ShippingAddress.ShipCountry}
        </td>
    </tr>
    {#/for}
</tbody>

As you can see the order object is used in the jtemplates code just like in .NET code.

You may have noticed the DateDeserialize() function followed by the extension method .format() in the snipped above. This is due to some date deserialization issues I ran into. The signature for the DateDeserialize method is as so:

1
2
3
function DateDeserialize(dateStr) {
  return eval('new' + dateStr.replace(/\//g, ' '));
}

This method is basically returning the evaluation of the date returned by the .NET framework (ex: /Date(894427200000)/), replacing the / with a space with the keyword "new" in front of it. This will return us a JavaScript Date object. Then I'm using the .format() extension method from the included MSAjax framework. It took me a little while to figure out, but once I did I fell in love. You can't put a price on full on object-oriented programming!

Special thanks to Dave Ward for opening my eyes to the power of JQuery!

Hope this helps!

View Comments
code asp.net
2008
08/26/2008

LINQ Distinct, a DataTable and the IEqualityComparer

In a recent situation I was trying to pull some aggregates out of a DataTable using LINQ. I needed to get the rows of the DataTable with a Distinct clause, but my aggregates would be on other columns of the row. The problem is that when you call LINQ’s Distinct() extension method with no arguments, it uses the "default IEqualityComparer". This means that it will work if you use the Select() extension method, only returning the column you want the distinct on. Well that works great, unless you need more columns from the DataTable.

The solution here is simple. Write a custom DataRow comparer that compares the DataRow against the column you are trying to put the distinct on. Here is an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class PersonDataRowComparer : IEqualityComparer<DataRow>
{
    #region IEqualityComparer<DataRow> Members
    
    public bool Equals(DataRow x, DataRow y)
    {
        return (x.Field<int>("PersonID") == y.Field<int>("PersonID"));
    }
 
    public int GetHashCode(DataRow obj)
    {
        return obj.ToString().GetHashCode();
    }
 
    #endregion
}

Once we inherit IEqualityComparer<T> (T being the type we want to do the comparison on) all we do is fill in the Equals() and the GetHashCode() methods. In the Equals() method, we just tell the DataRows to compare the fields "PersonID" and return if they are equal. This will tell LINQ if the DataRow is distinct or not.

Hope this helps!

View Comments
code .net linq c#
2008
06/03/2008

Strongly Typed Dynamic User Controls

A short time ago I was confronted with a serious problem. What I needed to do was dynamically choose a UserControl as well as fire methods from that UserControl. The problem lies in the fact that a UserControl does not implement my custom methods that I needed for my controls. Each control was similar and would have the same methods but it would have different display characteristics.

That was when I had a small epiphany. Why can’t I just make an abstract base class? Well the answer is you can! Sometimes I am prone to forget how .NET allows me to customize pre-defined classes. What we can do is create an abstract base class that inherits the UserControl class, then have our UserControls inherit from our base class.

First we will create our abstract base class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;

/// <summary>
/// Base class to be inherited by a UserControl that displays the date
/// </summary>
public abstract class DateTimeDisplayControl : UserControl
{
    /// <summary>
    /// Updates the date time inside the user control.
    /// </summary>
    public abstract void UpdateDateTime();
}

So in the snippet above, we have created a class called DateTimeDisplayControl. This inherits from UserControl and will have to override the abstract method UpdateDateTime().

Now we can create a couple of UserControls that inherit from our DisplayDateTimeControl class. The first control will be called "ControlOne".

Here is the *.ascx code:

1
2
3
4
5
6
7
<%@ Control Language="C#" AutoEventWireup="true" CodeFile="ControlOne.ascx.cs" Inherits="UserControls_ControlOne" %>
<p>User control one</p>
<asp:UpdatePanel ID="udp1"  runat="server" UpdateMode="Conditional">
    <ContentTemplate>
        <asp:Label ID="lblDateTime" runat="server" />
    </ContentTemplate>
</asp:UpdatePanel>

Here is the code behind:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;

public partial class UserControls_ControlOne : DateTimeDisplayControl
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
            UpdateDateTime();
    }

    public override void UpdateDateTime()
    {
        lblDateTime.Text = DateTime.Now.ToString();
        udp1.Update();
    }
}

As you can see, ControlOne contains an UpdatePanel with a Label inside of it. The Label will display the date and time. We will call our second control "ControlTwo" and it will look exactly like ControlOne, only it will say "User control two" inside of it.

Now we will create the actual *.aspx page to display the controls.

Here is the *.aspx code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<%@ Page Language="C#" AutoEventWireup="true"  CodeFile="Default.aspx.cs" Inherits="_Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml&quot;>
<head runat="server">
    <title>Strongly Typed Dynamic User Controls</title>
</head>
<body>
    <form id="form1" runat="server">
        <asp:ScriptManager ID="sm1" runat="server" />
        <asp:UpdatePanel ID="udp" runat="server" UpdateMode="Conditional">
            <ContentTemplate>
                <asp:Panel ID="pnlContent" runat="server" />
            </ContentTemplate>
            <Triggers>
                <asp:AsyncPostBackTrigger ControlID="btnUseControlOne" EventName="Click" />
                <asp:AsyncPostBackTrigger ControlID="btnUseControlTwo" EventName="Click" />
                <asp:AsyncPostBackTrigger ControlID="btnUpdateDateTime" EventName="Click" />
            </Triggers>
        </asp:UpdatePanel>
        <p>
            <asp:Button ID="btnUseControlOne" runat="server" Text="Use Control One"
                onclick="btnUseControlOne_Click" />&nbsp;
            <asp:Button ID="btnUseControlTwo" runat="server" Text="Use Control Two"
                onclick="btnUseControlTwo_Click" />&nbsp;
            <asp:Button ID="btnUpdateDateTime" runat="server" Text="Update Content"
                onclick="btnUpdateDateTime_Click" />
        </p>
    </form>
</body>
</html>

Here is the code behind:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
using System;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;

public partial class _Default : System.Web.UI.Page
{
    private string _controlVirtualPath = string.Empty;
    private DateTimeDisplayControl _DateTimeDisplayControl = null;

    private string ControlVirtualPath
    {
        get
        {
            if (string.IsNullOrEmpty(_controlVirtualPath))
                _controlVirtualPath = ViewState["ControlVirtualPath"].ToString();
            ViewState["ControlVirtualPath"] = _controlVirtualPath;
            if (string.IsNullOrEmpty(_controlVirtualPath))
                throw new ApplicationException("The control virtual path was not found");
            return _controlVirtualPath;
        }
    }

    private DateTimeDisplayControl LoadedAjaxControl
    {
        get
        {
            if (_DateTimeDisplayControl == null)
            {
                _DateTimeDisplayControl = (DateTimeDisplayControl)Page.LoadControl(ControlVirtualPath);
            }
            return _DateTimeDisplayControl;
        }
    }

    private void LoadAndDisplayUserControl()
    {
        pnlContent.Controls.Add(LoadedAjaxControl);
    }

    private void LoadAndDisplayUserControl(string controlVirtualPath)
    {
        _controlVirtualPath = controlVirtualPath;
        pnlContent.Controls.Add(LoadedAjaxControl);
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
            LoadAndDisplayUserControl("~/UserControls/ControlOne.ascx");
    }

    protected void btnUseControlOne_Click(object sender, EventArgs e)
    {
        LoadAndDisplayUserControl("~/UserControls/ControlOne.ascx");
    }

    protected void btnUseControlTwo_Click(object sender, EventArgs e)
    {
        LoadAndDisplayUserControl("~/UserControls/ControlTwo.ascx");
    }

    protected void btnUpdateDateTime_Click(object sender, EventArgs e)
    {
        LoadAndDisplayUserControl();
        LoadedAjaxControl.UpdateDateTime();
    }
}

As you may see, the *.aspx page will load up ControlOne by default. There are 3 buttons on the page that will allow you to swap out ControlOne and ControlTwo as well as call the UpdateDateTime() method of the controls.

That is all there is to it! One important note is that I am using a private property to get the loaded control, this is important to note because you will need to call that UpdateDateTime() method on the instance of the control that you rendered to the page. I don’t know why I didn’t think of this long ago, but I hope you will find it as useful as I did!

Happy coding!

View Comments
code asp.net .net c#
2008
04/21/2008

Using the Event Model: Throwing and Handling Custom Events

If you haven’t tried using the event model in .NET you don’t know what you’re missing. If this is the case, then I’m glad you’re here. Events are a very nice way to add flexibility to your projects and eliminate cross cutting concerns. You can use them for a variety of things including validation and logging. You can think of an event as sort of an All Points Bulletin (APB) throughout your application. Once you declare and throw an event, every place in your code that has an event handler for that event will be executed. Events can be both static or per instance. You use events every time you build an ASP.NET website. The Page_Load event, Button_Click event, etc… It is like an application wide notification that something is happening.

An important note is that all event handlers that have been moved to the call stack will be fired. So when you call out to your custom event, all objects that are in the call stack with an event handler for that event will be fired. Another thing to keep in mind is that there is no guaranteed order in which the events will be fired. If you are in need of doing something that requires a specific order, you should use more events or take another approach entirely.

In this project, we will create some events and handle them in a logging system. The first thing we will need to do is set up an event delegate to strongly type our event. Along with doing that, I like to setup some custom event arguments that will take in the object(s) that I will be dealing with during the event. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using System; using System.Collections.Generic; 
 
//Delegate for a PersonEvent 
public delegate void PersonEvent(PersonEventArgs e); 
 
public class PersonEventArgs : EventArgs 
{     
    public PersonEventArgs()     
    {              
    
    }     
    
    public PersonEventArgs(Person person)     
    {         
        this.Person = person;     
    }     
    
    public PersonEventArgs(List<Person> personList)     
    {         
        this.PersonList = personList;     
    }     
    
    //Person the action will be on     
    public Person Person { get; private set; }     
    
    //List of person the action will be on     
    public List<Person> PersonList { get; private set; }     
    
    //For canceling action     
    public bool Cancel { get; set; } 
}

Ok, Now all we have to do is declare and throw our events. When declaring our events, they will be of the type PersonEvent. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
using System.Collections.Generic; 
using System.ComponentModel; 
 
[DataObject(true)] 
public class PersonBLL 
{     
    //Declare events     
    public static event PersonEvent Pre_Get;     
    public static event PersonEvent Post_Get;     
    public static event PersonEvent Pre_Insert;     
    public static event PersonEvent Post_Insert;     
    public static event PersonEvent Pre_Update;     
    public static event PersonEvent Post_Update;     
    public static event PersonEvent Pre_Delete;     
    public static event PersonEvent Post_Delete;     
    
    [DataObjectMethod(DataObjectMethodType.Select)]     
    public List<PersonPresentationShell> GetPeople()     
    {         
        //Call out to event handler         
        if (Pre_Get != null)         
        {             
            PersonEventArgs args = new PersonEventArgs();             
            Pre_Get(args);             
            if (args.Cancel) return null;         
        }         
        
        List<PersonPresentationShell> result = new List<PersonPresentationShell>();         
        List<Person> personList = DataAccessFactory.GetPeople();         
        foreach (Person item in personList)         
        {             
            result.Add(new PersonPresentationShell(item));         
        }         
        
        //Call out to event handler         
        if (Post_Get != null)         
        {           
            PersonEventArgs args = new PersonEventArgs(personList);             
            Post_Get(args);             
            if (args.Cancel) return null;         
        }         
        
        return result;     
    }     
    
    [DataObjectMethod(DataObjectMethodType.Update)]     
    public void UpdatePerson(PersonPresentationShell p)     
    {         
        //Call out to event handler         
        if (Pre_Update != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Pre_Update(args);             
            if (args.Cancel) return;         
        }         
        
        DataAccessFactory.UpdatePerson(p.Person);         
        
        //Call out to event handler         
        if (Post_Update != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Post_Update(args);         
        }     
    }     
    
    [DataObjectMethod(DataObjectMethodType.Delete)]     
    public void DeletePerson(PersonPresentationShell p)     
    {         
        //Call out to event handler         
        if (Pre_Delete != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Pre_Delete(args);             
            if (args.Cancel) return;         
        }         
        
        DataAccessFactory.DeletePerson(p.Person);         
        
        //Call out to event handler         
        if (Post_Delete != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Post_Delete(args);         
        }     
    }     
    
    [DataObjectMethod(DataObjectMethodType.Insert)]     
    public void InsertPerson(PersonPresentationShell p)     
    {         
        //Call out to event handler         
        if (Pre_Insert != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Pre_Insert(args);             
            if (args.Cancel) return;         
        }         
        
        DataAccessFactory.InsertPerson(p.Person);         
        
        //Call out to event handler         
        if (Post_Insert != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Post_Insert(args);         
        }     
    } 
}

There we have it! An event will now be thrown before and after every get, insert, update and delete. Now we have to set up some event handlers in our logging object. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
using System; 
using System.IO; 
using System.Web; 
 
public class Logger 
{     
    //Set the log file location     
    private static string _logFileLocation = HttpContext.Current.Server.MapPath("~/App_Data/logfile.log");     
    
    static Logger()     
    {         
        //Attach event handlers         
        PersonBLL.Pre_Delete += new PersonEvent(PersonBLL_Pre_Delete);         
        PersonBLL.Post_Delete += new PersonEvent(PersonBLL_Post_Delete);         
        PersonBLL.Pre_Get += new PersonEvent(PersonBLL_Pre_Get);         
        PersonBLL.Post_Get += new PersonEvent(PersonBLL_Post_Get);         
        PersonBLL.Pre_Insert += new PersonEvent(PersonBLL_Pre_Insert);         
        PersonBLL.Post_Insert += new PersonEvent(PersonBLL_Post_Insert);         
        PersonBLL.Pre_Update += new PersonEvent(PersonBLL_Pre_Update);         
        PersonBLL.Post_Update += new PersonEvent(PersonBLL_Post_Update);     
    }     
    
    static void PersonBLL_Post_Update(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " was updated”);     
    }     
    
    static void PersonBLL_Pre_Update(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " is about to be updated”);     
    }     
    
    static void PersonBLL_Post_Insert(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " was inserted”);     
    }     
    
    static void PersonBLL_Pre_Insert(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " is about to be inserted”);     
    }     
    
    static void PersonBLL_Post_Get(PersonEventArgs e)     
    {         
        WriteToLogFile("The people were gotten”);     
    }     
    
    static void PersonBLL_Pre_Get(PersonEventArgs e)     
    {         
        WriteToLogFile("The people are about to be gotten”);     
    }     
    
    static void PersonBLL_Post_Delete(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " was deleted”);     
    }     
    
    static void PersonBLL_Pre_Delete(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " is about to be deleted”);     
    }     
    
    public static void WriteToLogFile(string message)     
    {         
        DateTime now = DateTime.Now;         
        using(StreamWriter sw = File.AppendText(_logFileLocation))         
        {             
            sw.WriteLine(now.ToString() + " - " + message);         
        }     
    } 
}

Finally, we have to create an instance of our logger class in the Global.asax file to attach our event handlers to our events when the application starts. 

1
2
3
4
5
6
void Application_Start(object sender, EventArgs e)  
{     
    //Create an instance of the logger     
    //To attach event handlers     
    Logger logger = new Logger(); 
}

There we have it. Now on every CRUD operation in our application, a log entry will be written with some data about that action. Once you get the hang of it events become extremely useful. One big instance I like to use it for is authorization of performing an action in a membership and roles scenario.

Hope this helps!

View Comments
code .net c#
2008
04/14/2008

Clean Up ASP.NETs Head Tag With ControlAdapters

Ok, if you’re anything like me you absolutely gag when you see the rendered content of the ASP.NET head tag. It is all rendered out inline for some reason. I’m not 100% sure about the affects of it on web marketing, but I know one thing is for sure… It certainly doesn’t help your rankings any. At the very least it looks gross and it can be easily fixed with some portable c# files that you can include in any project. I found a reference here about it, so I picked it up and ran with it.

A couple of good things to note is the placement of some key pieces for control adapters in the .NET framework. The ControlAdapter class should be inherited for every control adapter you create, it can be found in the System.Web.UI.Adapters namespace. All of the tags we will be overriding belong to the System.Web.UI.HtmlControls namespace.

The first tag we will override is the head tag itself. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System.Web.UI; 
using System.Web.UI.Adapters; 
using System.Web.UI.HtmlControls; 
namespace Rollem.ControlAdapters 
{     
    public class HtmlHeadAdapter : ControlAdapter     
    {         
        protected override void Render(HtmlTextWriter writer)         
        {             
            HtmlHead headTag = (HtmlHead)this.Control;             
            writer.WriteBeginTag("head");             
            if (!string.IsNullOrEmpty(headTag.ID))                 
                writer.WriteAttribute("id", headTag.ClientID);             
            writer.Write(HtmlTextWriter.TagRightChar);             
            foreach (Control item in headTag.Controls)                 
                item.RenderControl(writer);             
            writer.WriteLine("");         
        }     
    }  
}

Next we are on to the title tag. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using System.Web.UI; 
using System.Web.UI.Adapters; 
namespace Rollem.ControlAdapters 
{     
    public class HtmlTitleAdapter : ControlAdapter     
    {         
        protected override void Render(HtmlTextWriter writer)         
        {             
            writer.WriteLine();             
            writer.WriteFullBeginTag("title");             
            writer.Write(Page.Title);             
            writer.WriteEndTag("title");             
            writer.WriteLine();         
        }     
    }  
}

Now the link tags. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using System.Collections; 
using System.Web.UI; 
using System.Web.UI.Adapters; 
using System.Web.UI.HtmlControls; 
namespace Rollem.ControlAdapters 
{     
    public class HtmlLinkAdapter : ControlAdapter     
    {         
        protected override void Render(HtmlTextWriter writer)         
        {             
            HtmlLink linkTag = (HtmlLink)this.Control;             
            writer.Write("<link");             
            AttributeCollection attributes = linkTag.Attributes;             
            IEnumerator keys = linkTag.Attributes.Keys.GetEnumerator();             
            while (keys.MoveNext())             
            {                 
                string key = (string)keys.Current;                 
                if (key.ToLower() == "href" && attributes[key].Contains("~"))                     
                    writer.WriteAttribute(key, linkTag.ResolveClientUrl(attributes[key]));                 
                else                     
                    writer.WriteAttribute(key, attributes[key]);             
                writer.WriteLine(" />");         
            }     
        } 
    }
}

Last but not least, the meta tags. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System.Web.UI; 
using System.Web.UI.Adapters; 
using System.Web.UI.HtmlControls; 
namespace Rollem.ControlAdapters 
{     
    public class HtmlMetaAdapter : ControlAdapter     
    {         
        protected override void Render(HtmlTextWriter writer)         
        {             
            HtmlMeta metaTag = (HtmlMeta)this.Control;             
            writer.WriteBeginTag("meta");             
            if (!string.IsNullOrEmpty(metaTag.HttpEquiv))                 
                writer.WriteAttribute("http-equiv", metaTag.HttpEquiv);             
            if (!string.IsNullOrEmpty(metaTag.Name))                 
                writer.WriteAttribute("name", metaTag.Name);             
            writer.WriteAttribute("content", metaTag.Content);             
            writer.WriteLine(HtmlTextWriter.SelfClosingTagEnd);         
        }     
    }  
}

Now all we have to do is setup a *.browser file in the App_Browsers folder to map the control adapter overrides. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<browsers>     
    <browser refID="Default">         
        <controlAdapters>             
            <adapter controlType="System.Web.UI.HtmlControls.HtmlHead"                 
                    adapterType="Rollem.ControlAdapters.HtmlHeadAdapter" />             
            <adapter controlType="System.Web.UI.HtmlControls.HtmlTitle"                 
                    adapterType="Rollem.ControlAdapters.HtmlTitleAdapter" />             
            <adapter controlType="System.Web.UI.HtmlControls.HtmlMeta"                 
                    adapterType="Rollem.ControlAdapters.HtmlMetaAdapter" />             
            <adapter controlType="System.Web.UI.HtmlControls.HtmlLink"                 
                    adapterType="Rollem.ControlAdapters.HtmlLinkAdapter" />         
        </controlAdapters>     
    </browser> 
</browsers>

Now if we right click and view source we will see a nice clean head tag.

Don’t live a moment longer with that ugly ASP.NET rendered head tag! 

Hope this helps!

View Comments
code asp.net