ASP.NET 数据绑定包装类的框架

Question

显然 ASP.NET 不允许将数据绑定到动态对象。真是太糟糕了，因为我发现这样的语法非常有用：

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" />

在本例中，AsDynamic() 将返回一个类，该类将配置 .ToEnumerable( 返回的动态对象) ） 稍后（因为 您无法实现 IEnumerable) 有效地将属性添加到包装的数据对象。对 FirstName 和 LastName 的请求将由真实对象“提供”，而对 FullName 的请求将被路由到要动态评估的委托或表达式。

这是一个简单的示例，因为在大多数情况下，您可以轻松地将 FullName 属性添加到 User 对象，并且可以使用 TemplatedField 轻松实现此目的。

但是，如果添加的属性在没有几行数据绑定代码隐藏的情况下很难在 TemplatedField 中实现，该怎么办？如果您不控制 User 类的源代码怎么办？或者，如果您无法将该属性添加到 User，因为它的计算依赖于一个程序集，而该程序集本身又依赖于 User 的程序集，该怎么办？ （循环引用问题）

因此，拥有一个像这样非常易于应用的数据绑定包装器会很棒，您不必每次都生成一个全新的类。

那么我真正追求的是什么？

有没有任何框架或技术可以实现这种事情？上面的确切语法并不重要，只是能够动态向类添加内容并在数据绑定中使用这些代理，而无需一堆手动管道代码。

Answer 1

我找到了使用 C# 解决（某些）问题的三种方法，以及使用 Visual Studio 工具扩展其中一些方法的方法。

匿名类型

ASP.NET 可以将数据绑定到匿名类型：

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

匿名类型仍然可以轻松访问原始类型（在本例中通过 User 属性）。这将使数据绑定相对简单（使用 ），并且您已将复杂的逻辑移至在 User 上运行的单独方法对象。

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

数据绑定语法应放置在 的 ItemTemplate 内，但为了简洁起见，我省略了该代码。当然，最后一个属性也可以使用 显示：

<asp:BoundField DataField="FullName" />

请注意，您不必在匿名中映射原始类型的 each 属性类型，您可以只将一个属性映射到原始对象。 （唯一的？）缺点是您不能再对这些属性使用 ，但必须使用 。

扩展方法

要补充此方法，您可以使用扩展方法来“附加” ' 即使您无权访问类，也可以使用该类的方法' 源：

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

对于数据绑定，我们必须使用 ：

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

部分类

另一种选择，自 C# 起可用2.0，就是写一个部分类，但前提是原始类也声明为部分的，并且在您的项目中声明（同一模块的一部分）。如果 User 类是使用工具生成的，例如，如果您在项目中使用某种自动数据库映射器工具，则此方法非常有用。

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

对于数据绑定，我们现在回到使用 ''：

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

这些都是 C# 编译器和 .NET 运行时的可能性，因此它们属于技术类别而不是框架类别。当然，也可以使用基本继承，但它可能不适用于您的情况？

T4 文本模板

如果您对数据绑定类的外观有非常具体的需求，但无法使用上述任何方法，您可以随时查看 T4 模板。 （它们适用于 ASP.NET Web 应用程序项目，但不适用于 ASP.NET 网站项目。）

• 所有帖子Oleg Sych 关于 T4 模板的博客

使用这些模板，您可以在设计时生成代码，例如创建一个浅层部分类 UserViewModel，将所有属性透明地映射到内部 User 对象。然后，使用分部类方法，您可以使用 .cs 文件中的另一个分部类声明向此类型添加额外的属性和方法，并且只需针对您的 UserViewModel 进行数据绑定：

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

数据绑定再次变得简单使用 ：

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

使用 T4 模板，您可以为所有域类型自动生成这些自定义视图模型类。在 T4 中使用反射时，有一些注意事项：

• 如何使用T4生成Decorator类

Answer 2

您可能想查看 Clay 库（请参阅 这个伟大的概述）：

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;

当然，给猫剥皮的方法不止一种，尤其是在语法上。另外，我还没有深入研究它（这是你的工作！；）所以我不知道 Clay 对象是否可以覆盖到现有对象上，或者你是否需要从现有对象中填充新的 Clay User像我一样。最重要的是，如果您从接口继承它们，Clay 对象就会存在于 CLR 中，获得智能感知，并且行为就像真正的非动态对象（如果我没看错的话）。

Answer 3

实现此目的的一种方法是使用 asp:TemplateField。

您还可以使用 Dynamic Linq 来执行此操作，请参阅 ScottGu 关于 Dynamic Linq 基础知识的博客。

然后，您可以使用 Dynamic Linq 创建语句的动态选择部分。下面是一些用于创建 select 语句的代码，该语句选择所有基础对象的属性并基于动态表达式创建额外的属性。

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 + ")";
}

其使用示例如下：

    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();

您需要将其包含在标头中：

using System.Linq.Dynamic;

Answer 4

阅读 Jesse Smith 关于 Clay 库的回答后，我研究了 Clay，发现它并不真正适合我所追求的目标。然而，Clay 在内部使用 Castle Project 的 DynamicProxy 库，这确实有一些有趣的东西虽然它并不完美，但肯定接近我希望存在的东西。

Castle DynamicProxy 可以通过发出代码来创建对象的代理，然后拦截对其的调用。对业务对象的唯一要求是方法和属性需要标记为虚拟的，以便 Castle 拦截对它们的调用。

然后，您可以将“mixins”添加到代理对象中。我将用问题中的 User 示例进行演示：

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

如果我们想将 FullName 添加到该对象的代理中，那么我们需要做一些工作来实现这一点，方法是创建一个声明该属性的接口，并且然后是一个可以提供现有用户值的实现对象：

public interface IUserProxy
{
    string FullName { get; }
}

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

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

现在对于数据绑定，我真的很想在可枚举上使用它，因此扩展方法可以完成创建代理和添加混合的工作。我们将允许调用代码使用 Func 提供 mixin（基本上只是对象），以便我们可以使用 lambda 表达式定义它们：

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);
        }
    }
}

然后是我们的客户端代码（我在 Windows 控制台应用程序中进行模拟，因为它更容易测试）可以如下所示。当我们到达提供 mixin 的 lambda 时，我们返回一个新的 UserProxyImpl，并将基本的 User 对象传递给它。 Castle 分析 UserProxyImpl，注意到它实现了 IUserProxy，并导致发出的代理类使用该实现来实现该接口。所有其他属性都会流向原始对象的虚拟实现，而不会被代理拦截。

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();
    }
}

我真的想要一些东西，你可以只通过定义一些 lambda 来创建代理，而不需要定义额外的接口或实现类，但这似乎是唯一的方法。当然，您必须考虑相对于其他方法是否真的值得发出这些自定义类型来完成这项工作。

这是完整代码的要点，因此您无需将其组装即可提供尝试一下。