Framework for ASP.NET data-binding wrapper classes

Question

Apparently ASP.NET doesn't allow data-binding to dynamic objects. Major bummer, because I could see a syntax like this being really useful:

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

...

// No this doesn't exist, I just wish it did!
MyGrid.DataSource = GetAllUsers()
    .AsDynamic()
        .WithProperty("FullName", user => user.FirstName + " " + user.LastName)
    .ToEnumerable(); // returns IEnumerable<dynamic>
MyGrid.DataBind()

...

<asp:BoundField DataField="FirstName" HeaderText="First Name" />
<asp:BoundField DataField="LastName" HeaderText="Last Name" />
<asp:BoundField DataField="FullName" HeaderText="Full Name" />

In this example, AsDynamic() would return a class that would configure the dynamic objects that would be returned by .ToEnumerable() later (because you can't implement IEnumerable<dynamic>) effectively adding properties to the wrapped data object. The requests for FirstName and LastName would be "served" by the real object, and the request for FullName would be routed to a delegate or expression to be evaluated dynamically.

This is a trivial example, because in most cases you could easily add a FullName property to the User object, and you could easily pull this off with a TemplatedField.

But what if the added property was way too difficult to implement in a TemplatedField without several lines of databinding codebehind? And what if you didn't control the source code for the User class? Or what if you can't add the property to User because its calculation is dependent on an assembly which itself depends on User's assembly? (circular reference problem)

For this reason it would be great to have a very easy-to-apply data binding wrapper such as this, where you don't have to generate a brand new class every single time.

So what am I really after?

Are there any frameworks or techniques out there that allow this kind of thing? The exact syntax above isn't really important, just the ability to dynamically add stuff to classes and use those proxies in data-binding, without a bunch of manual plumbing code.

Answer 1

I find three ways to solve (some) of your problems using C# and a way to extend some of these approaches using Visual Studio tools.

Anonymous types

ASP.NET can data bind to anonymous types:

DataGrid.DataSource = GetAllUsers().
  .AsQueryable()
  .Select(u => new { User = u, FullName = GetFullName(u) });
DataGrid.DataBind()

The anonymous type can still give easy access to the original type (in this example through the User property). This will make data binding relatively easy (using <asp:TemplateField>), and you have moved the complex logic to a separate method that operates on a User object.

<%# Eval("User.FirstName") %>
<%# Eval("User.LastName") %>
<%# Eval("FullName") %>

The data binding syntax should be placed inside the ItemTemplate of the <asp:TemplateField>, but I have omitted that code for brevity. Of course the last property can also be displayed using the <asp:BoundField>:

<asp:BoundField DataField="FullName" />

Notice that you don't have to map each property of the original type in the anonymous type, you can just map one property to the original object. The (only?) drawback is that you can no longer use <asp:BoundField> for those properties but you must use <asp:TemplateField>.

Extension methods

To complement this approach, you could use extension methods to 'attach' methods to a class even when you don't have access to the class' source:

public static class UserExtensions
{
  public static string GetFullName(this User user)
  {
      return user.FirstName + " " + user.LastName;
  }
}

For data binding we must use <asp:TemplateField>:

<%# Eval("User.FirstName") %>
<%# Eval("User.LastName") %>
<%# (Container.DataItem as User).GetFullName() %>

Partial classes

Another option, available since C# 2.0, is to write a partial class, but only if the original class is also declared partial and is declared in your project (part of the same module). This approach is useful if the User class is generated with a tool, for instance if you use some kind of automatic database mapper tool in your project.

public partial class User
{
    public string FullName
    {
        get { return this.FirstName + " " + this.LastName; }
    }
}

For data binding we are now back to using '':

<asp:BoundField DataField="FirstName" />
<asp:BoundField DataField="LastName" />
<asp:BoundField DataField="FullName" />

These are all possibilities of the C# compiler and the .NET runtime, so they fall in the category of techniques instead of frameworks. Of course, basic inheritance could also be used, but it may not be applicable in your situation?

T4 Text Templates

If you have very specific needs about how the data bound class should look like but can't use any of the approaches above, you can always look into T4 templates in Visual Studio. (They work in ASP.NET Web Application projects but not in ASP.NET Web Site projects.)

• All posts on Oleg Sych's blog about T4 templates

With these templates you can generate code at design time, for instance to create a shallow, partial class UserViewModel that maps all properties to an internal User object transparently. Then, using the partial class approach, you can add extra properties and methods to this type using another partial class declaration in a .cs file and simply data bind against your UserViewModel:

DataGrid.DataSource = GetAllUsers().
  .AsQueryable()
  .Select(u => new UserViewModel(u));
DataGrid.DataBind()

Data bind becomes straight-forward again using <asp:BoundField>:

<asp:BoundField DataField="FirstName" />
<asp:BoundField DataField="LastName" />
<asp:BoundField DataField="FullName" />

Using T4 templates you could generate these custom view model classes automatically for all your domain types. When using reflection in T4 there are caveats:

• How to use T4 to generate Decorator classes

Answer 2

You might want to look into the Clay library (see this great overview):

public interface IUser {
    public string FirstName { get; set; }
    public string LastName  { get; set; }
    public string FullName  { get; set; }
} 

dynamic New = new ClayFactory();
existingUser = //grab your existing user here
IUser clayUser = New.User(){
    FirstName: existingUser.FirstName,
    LastName: existingUser.LastName,
    FullName: existingUser.FirstName + " " + existingUser.LastName;

Of course, there is more than one way to skin that cat, especially syntactically. Also, I haven't dug into it very deeply (that's your job! ;) so I don't know if a Clay object can glom onto an existing object, or if you'll need to populate the new Clay User from the existing one like I did. The great part is, if you inherit them from an interface, Clay objects live in the CLR, get Intellisense, and act just like real non-dynamic objects, if I'm reading the article right.

Answer 3

One way to achieve this is to use asp:TemplateField.

You can also use Dynamic Linq to do this, see ScottGu's blog about the basics of Dynamic Linq.

You could then use Dynamic Linq to create a dynamic select part of a statement. Here is some code for creating a select statement that select all the base object's properties and creates extra properties based on dynamic expressions.

public class ExtraProperty
{
    public string Name { get; set; }
    public string Expression { get; set; }
}


/// <summary>
/// Creates a string on the form "new (property1, property2, ..., expression1 as extraproperty1, ... )
/// </summary>
/// <param name="t"></param>
/// <param name="extraProperties"></param>
/// <returns></returns>
public string CreateSelectClauseWithProperty(Type objecType, ExtraProperty[] extraProperties)
{
    string ret = "new(";
    bool notFirst = false;
    System.Reflection.PropertyInfo[] typeProps = objecType.GetProperties();


    // Equivalent of "Select objectType.*"
    foreach (System.Reflection.PropertyInfo p in typeProps)
    {
        if (notFirst)
            ret += ",";
        else
            notFirst = true;
        ret += p.Name;
    }

    // Equivalent of "expression1 as name1, expression2 as name2, ..." - giving the extra columns
    foreach (ExtraProperty ep in extraProperties)
    {
        if (notFirst)
            ret += ",";
        else
            notFirst = true;
        ret += ep.Expression + " as " + ep.Name;
    }
    return ret + ")";
}

A sample use of this would be like this:

    MyGrid.AutoGenerateColumns = false;
    string selectClause = CreateSelectClauseWithProperty(typeof(User),
            new ExtraProperty[] { 
                    new ExtraProperty() 
                    { Name = "FullName", Expression = "FirstName + \" \" + LastName" }
                }
                );
    IQueryable<User> list = GetAllUsers();
    var query = list.Select( selectClause );
    MyGrid.DataSource =  query;
    MyGrid.DataBind();

You need to include this in your header:

using System.Linq.Dynamic;

Answer 4

After reading Jesse Smith's answer regarding the Clay library, I looked into Clay and decided that it wasn't really suited to what I'm after. However, internally Clay uses the Castle Project's DynamicProxy library, and that does have some interesting stuff in it that, while not perfect, certainly approaches what I wish existed.

A Castle DynamicProxy can create a proxy of an object by emitting code, and then intercepting calls to it. About the only requirement on your business objects is that methods and properties need to be marked as virtual in order for Castle to intercept calls to them.

You can then add "mixins" to your proxy object. I'll demonstrate with the example of User from the question:

public class User
{
    public virtual string FirstName { get; set; }
    public virtual string LastName { get; set; }
}

If we want to add FullName to a proxy of this object, then we need to do a little bit of plumbing to enable that, by creating an interface that declares the property, and then an implementation object that can supply the value from the existing user:

public interface IUserProxy
{
    string FullName { get; }
}

public class UserProxyImpl : IUserProxy
{
    public User User { get; set; }

    public string FullName
    {
        get { return User.FirstName + " " + User.LastName; }
    }
}

Now for data-binding, I'd really like to use this on an enumerable, so an extension method can do the work of creating the proxy and adding mixins. We'll allow the calling code to provide the mixins (which are basically just objects) using a Func<T, object> so that we can define them using lambda expressions:

public static class ProxyExtensions
{
    public static IEnumerable<T> ProxyAddMixins<T>(this IEnumerable<T> collection, params Func<T, object>[] mixinSelectors)
        where T : class
    {
        ProxyGenerator factory = new ProxyGenerator();
        foreach (T item in collection)
        {
            ProxyGenerationOptions o = new ProxyGenerationOptions();
            foreach (var func in mixinSelectors)
            {
                object mixin = func(item);
                o.AddMixinInstance(mixin);
            }
            yield return factory.CreateClassProxyWithTarget<T>(item, o);
        }
    }
}

Then our client code (which I'm mocking up in a Windows Console app because it's just easier to test) can look like this. When we get to the lambda for providing the mixins, we return a new UserProxyImpl passing in the base User object to it. Castle analyzes the UserProxyImpl, notices that it implements IUserProxy, and causes the emitted proxy class to implement that interface with that implementation. All other properties flow through to the original object's virtual implementations without being intercepted by the proxy.

class Program
{
    static void Main(string[] args)
    {
        List<User> users = new List<User>();
        users.Add(new User { FirstName = "John", LastName = "Doe" });
        users.Add(new User { FirstName = "Jane", LastName = "Doe" });

        var userProxies = users
            .ProxyAddMixins(u => new UserProxyImpl { User = u })
            .ToList();

        Console.WriteLine("First\tLast\tFull");
        foreach (var userProxy in userProxies)
        {
            Console.WriteLine("{0}\t{1}\t{2}",
                DataBinder.Eval(userProxy, "FirstName"),
                DataBinder.Eval(userProxy, "LastName"),
                DataBinder.Eval(userProxy, "FullName"));
        }
        Console.ReadLine();
    }
}

I really wanted something where you could just create the proxy just by defining some lambdas without defining an additional interface or implementation class, but this seems to be the only way to do that. Of course you have to take into consideration if it's really worth emitting these custom types to do this work vs. other methods.

Here is a gist of the he full code, so you don't have to assemble it to give it a try.