Using Generics to Create HtmlHelper Extension Methods

Question

Hi Guys

I'm not really familiar with creating generic methods, so I thought I'd put this question to the community & see what comes back. It might not even be a valid use of generics!

I'd like to create a HtmlHelper extension method where I can specify that the method is of a certain type. I pass into the method an instance of that type, and an instance of a TagBuilder object. I then specify the class attribute of the tag to be the type of object I passed in, with all the object's properties serialized into the tag's attributes.

edit... the benefit of this would be that I could then easily serialize my Html elements in into javascript objects for jQuerying to the server & Model Binding, as well as the ability to specify style for a type ...end edit

This code sample might clarify.

I have a type like this:

public class MyType
{
    public int Prop1 { get; set; }
    public int Prop2 { get; set; }

    public MyType(int val1, int val2)
    {
        this.Prop1 = val1;
        this.Prop2 = val2;
    }
}

What I'm thinking is to produce a helper method, maybe with a signature similar to this:

public static string GetTag<T>(this HtmlHelper h, object myType, TagBuilder tag)
{
    // cast myType to T //(i.e. MyType)
    // use reflection to get the properties in MyType
    // get values corresponding to the properties
    // build up tag's attribute/value pairs with properties.
}

Ideally I could then call:

<% var myType = new MyType(123, 234); %>
<% var tag = new TagBuilder("div"); %>
<%= Html.GetTag<MyType>(myType, tag) %>

and the html produced would be

<div class="MyType" prop1="123" prop2="234" />

And later on, I can call

<%= Html.GetTag<MyOtherType>(myOtherType, tag) %>

to get

<div class="MyOtherType" prop1="123" prop2="234" />

Is it even possible? Or am I looking at this totally the wrong way? Anyone care to fill me on on a better approach?

Thanks

Dave

Answer 1

I'm thinking generics is not exactly what you are looking for here.

Instead you might want to take one of two different approaches

1. Make all of your classes descend from a common one which has a virtual method called "Render" or something similiar. That way you can just call the classes render method.

2. Make all of your classes implement an Interface which has a Render method..

That you you would just call:

<%= myType.Render() %>

Although each class then has to implement it's own Render method, you would 1. avoid reflection, 2. have complete control on a class basis on what the output is.

Answer 2

For what you're trying to do, I think the main benefit of using generics would be to take advantage of type inference. If you declare your method as follows :

public static string GetTag<T>(this HtmlHelper h, T myObj, TagBuilder tag)

You won't have to specify the type parameter when calling it, because it will be inferred from the usage (i.e. the compiler will see that the second parameter's type is MyType, so it will guess that T == MyType).

But anyway, you don't really need to specify the type : the method could call GetType on the object, and use the resulting type the same way it would have used typeof(T), so generics aren't so useful here.

However, I see one reason to use them anyway : if you have an object of type MySubType, which inherits from MyType, you might want to render only properties defined in MyType : in that case you just have to specify MyType as the type parameter, overriding the type inference.

Here's a possible implementation :

public static string GetTag<T>(this HtmlHelper h, T myObj, TagBuilder tag)
{
    Type t = typeof(T);
    tag.Attributes.Add("class", t.Name);
    foreach (PropertyInfo prop in t.GetProperties())
    {
        object propValue = prop.GetValue(myObj, null);
        string stringValue = propValue != null ? propValue.ToString() : String.Empty;
        tag.Attributes.Add(prop.Name, stringValue);
    }
    return tag.ToString();
}