深入ASP.NET数据绑定（下）——多样的绑定方式

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› ASP.NET›ASP.NET编程经验

原作者: [db:作者] 来自: [db:来源] 收藏邀请

在这个系列的上篇中介绍了数据绑定语法的原理以及.NET中如何实现单向绑定，中篇我们简单的介绍了ASP.NET 2.0 中新增的Bind语法配合DataSourceControl来实现数据的自动双向绑定。这两部分的内容相对动态抽象并且不常接触，没有很好的源代码支持很难解释清楚，要想真正弄清它们的内部原理，还需要大家亲自动手去反编译分析动态编译的程序集。

在了解了数据绑定语法的原理后，我还想来谈谈我中实践过程中遇到的一些问题以及其它实用的绑定技巧。首先我们就来说说，特殊字段名的问题。我们知道在数据库当中，如果表名或字段名中包含有一些特殊的不能是合法的字符时，都会使用[]将它们引起来，以便他们能够正常使用。但是在<%# Eval("")%>的绑定语句当中，同时可以使用[]，但是对于字段名中包含 "(",")","[","]"这4个字符却始终运行出错。假设像我下面这样来绑定"电压(V)"：

<%# Eval("电压(V)")%>

那么就会得到一个运行时错误：

DataBinding:“System.Data.DataRowView”不包含名为“电压”的属性。

表明括号是被认为是一个特殊字符，那我们如果给字段名加上[]，如下：

<%# Eval("[电压(V)]")%>

此时，我们会得到另一个运行时错误：

电压(V 既不是表 DataTable1 的 DataColumn 也不是 DataRelation。

表明，即使加上[]也无法解决这个特殊字段名的问题。同时字段名中如果也存在中括号，也是会出现这样的问题的。但是这样的字段名却在GridView的自动生成列中能被正常绑定呢？问题会出现在哪里呢？分析和对比GridView的自动生成列与Eval这样的绑定语法在最终执行绑定代码上的不同，我们可以发现，GridView的自动生成列取值并不是使用DataBinder.Eval这个方法，它内部有自己的取值方式，但是在实现上却是大同小异的。那究竟是在哪里出现了问题呢？我们找出DataBinder类的定义：

[AspNetHostingPermission(SecurityAction.LinkDemand, Level=200)]
public sealed class DataBinder
{
    // Fields
    private static readonly char[] expressionPartSeparator = new char[] { '.' };
    private static readonly char[] indexExprEndChars = new char[] { ']', ')' };
    private static readonly char[] indexExprStartChars = new char[] { '[', '(' };
  
    // Methods
    public static object Eval(object container, string expression)
    {
        if (expression == null)
        {
            throw new ArgumentNullException("expression");
        }
        expression = expression.Trim();
        if (expression.Length == 0)
        {
            throw new ArgumentNullException("expression");
        }
        if (container == null)
        {
            return null;
        }
        string[] expressionParts = expression.Split(expressionPartSeparator);
        return Eval(container, expressionParts);
    }
  
    private static object Eval(object container, string[] expressionParts)
    {
        object propertyValue = container;
        for (int i = 0; (i < expressionParts.Length) && (propertyValue != null); i++)
        {
            string propName = expressionParts[i];
            if (propName.IndexOfAny(indexExprStartChars) < 0)
            {
                propertyValue = GetPropertyValue(propertyValue, propName);
            }
            else
            {
                propertyValue = GetIndexedPropertyValue(propertyValue, propName);
            }
        }
        return propertyValue;
    }
  
    public static string Eval(object container, string expression, string format)
    {
        object obj2 = Eval(container, expression);
        if ((obj2 == null) || (obj2 == DBNull.Value))
        {
            return string.Empty;
        }
        if (string.IsNullOrEmpty(format))
        {
            return obj2.ToString();
        }
        return string.Format(format, obj2);
    }
  
    public static object GetDataItem(object container)
    {
        bool flag;
        return GetDataItem(container, out flag);
    }
  
    public static object GetDataItem(object container, out bool foundDataItem)
    {
        if (container == null)
        {
            foundDataItem = false;
            return null;
        }
        IDataItemContainer container2 = container as IDataItemContainer;
        if (container2 != null)
        {
            foundDataItem = true;
            return container2.DataItem;
        }
        string name = "DataItem";
        PropertyInfo property = container.GetType().GetProperty(name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
        if (property == null)
        {
            foundDataItem = false;
            return null;
        }
        foundDataItem = true;
        return property.GetValue(container, null);
    }
  
    public static object GetIndexedPropertyValue(object container, string expr)
    {
        if (container == null)
        {
            throw new ArgumentNullException("container");
        }
        if (string.IsNullOrEmpty(expr))
        {
            throw new ArgumentNullException("expr");
        }
        object obj2 = null;
        bool flag = false;
        int length = expr.IndexOfAny(indexExprStartChars);
        int num2 = expr.IndexOfAny(indexExprEndChars, length + 1);
        if (((length < 0) || (num2 < 0)) || (num2 == (length + 1)))
        {
            throw new ArgumentException(SR.GetString("DataBinder_Invalid_Indexed_Expr", new object[] { expr }));
        }
        string propName = null;
        object obj3 = null;
        string s = expr.Substring(length + 1, (num2 - length) - 1).Trim();
        if (length != 0)
        {
            propName = expr.Substring(0, length);
        }
        if (s.Length != 0)
        {
            if (((s[0] == '"') && (s[s.Length - 1] == '"')) || ((s[0] == '\'') && (s[s.Length - 1] == '\'')))
            {
                obj3 = s.Substring(1, s.Length - 2);
            }
            else if (char.IsDigit(s[0]))
            {
                int num3;
                flag = int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out num3);
                if (flag)
                {
                    obj3 = num3;
                }
                else
                {
                    obj3 = s;
                }
            }
            else
            {
                obj3 = s;
            }
        }
        if (obj3 == null)
        {
            throw new ArgumentException(SR.GetString("DataBinder_Invalid_Indexed_Expr", new object[] { expr }));
        }
        object propertyValue = null;
        if ((propName != null) && (propName.Length != 0))
        {
            propertyValue = GetPropertyValue(container, propName);
        }
        else
        {
            propertyValue = container;
        }
        if (propertyValue == null)
        {
            return obj2;
        }
        Array array = propertyValue as Array;
        if ((array != null) && flag)
        {
            return array.GetValue((int) obj3);
        }
        if ((propertyValue is IList) && flag)
        {
            return ((IList) propertyValue)[(int) obj3];
        }
        PropertyInfo info = propertyValue.GetType().GetProperty("Item", BindingFlags.Public | BindingFlags.Instance, null, null, new Type[] { obj3.GetType() }, null);
        if (info == null)
        {
            throw new ArgumentException(SR.GetString("DataBinder_No_Indexed_Accessor", new object[] { propertyValue.GetType().FullName }));
        }
        return info.GetValue(propertyValue, new object[] { obj3 });
    }
  
    public static string GetIndexedPropertyValue(object container, string propName, string format)
    {
        object indexedPropertyValue = GetIndexedPropertyValue(container, propName);
        if ((indexedPropertyValue == null) || (indexedPropertyValue == DBNull.Value))
        {
            return string.Empty;
        }
        if (string.IsNullOrEmpty(format))
        {
            return indexedPropertyValue.ToString();
        }
        return string.Format(format, indexedPropertyValue);
    }
  
    public static object GetPropertyValue(object container, string propName)
    {
        if (container == null)
        {
            throw new ArgumentNullException("container");
        }
        if (string.IsNullOrEmpty(propName))
        {
            throw new ArgumentNullException("propName");
        }
        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(container).Find(propName, true);
        if (descriptor == null)
        {
            throw new HttpException(SR.GetString("DataBinder_Prop_Not_Found", new object[] { container.GetType().FullName, propName }));
        }
        return descriptor.GetValue(container);
    }
  
    public static string GetPropertyValue(object container, string propName, string format)
    {
        object propertyValue = GetPropertyValue(container, propName);
        if ((propertyValue == null) || (propertyValue == DBNull.Value))
        {
            return string.Empty;
        }
        if (string.IsNullOrEmpty(format))
        {
            return propertyValue.ToString();
        }
        return string.Format(format, propertyValue);
    }
  
    internal static bool IsNull(object value)
    {
        if ((value != null) && !Convert.IsDBNull(value))
        {
            return false;
        }
        return true;
    }
}

其中我们可以发现有三个静态只读变量：

private static readonly char[] expressionPartSeparator = new char[] { '.' };
private static readonly char[] indexExprEndChars = new char[] { ']', ')' };
private static readonly char[] indexExprStartChars = new char[] { '[', '(' };

OK，我们先不看代码，就应该知道问题就出在这个地方。当我们分析哪里用到indexExprEndChars时分找到这个方法：

public static object GetIndexedPropertyValue(object container, string expr)

我们不需要阅读里面的代码，通过下面的expr参数注释我们就可以很快得到答案：

expr 从 container 对象到要放置在绑定控件属性中的公共属性值的导航路径。此路径必须是以点分隔的属性或字段名称字符串，如 C# 中的 Tables[0].DefaultView.[0].Price 或 Visual Basic 中的 Tables(0).DefaultView.(0).Price。

它告诉我们，我们不仅可以使用字段名的方式，同时还可以使用索引下标的方式来绑定字段值（C#和VB，分别使用[]和()来取索引值），正因为如此，我们才不可以在字段名中使用括号和中括号。如上我们假设"电压(V)"字段的索引下标是2，那么我们可以像下面这样绑定，来解决特别字段名带来的问题： <td><%# Eval("[2])")%></td>

上面的注释同时还告诉，我们是可以通过一个对象的导航路径如对象.属性.子属性的方式来绑定一个数据项的间接属性，这个我们可以通过对expressionPartSeparator静态字段的使用，得以验证：

public static object Eval(object container, string expression)
{
    if (expression == null)
    {
        throw new ArgumentNullException("expression");
    }
    expression = expression.Trim();
    if (expression.Length == 0)
    {
        throw new ArgumentNullException("expression");
    }
    if (container == null)
    {
        return null;
    }
    string[] expressionParts = expression.Split(expressionPartSeparator);
    return Eval(container, expressionParts);
}
private static object Eval(object container, string[] expressionParts)
{
    object propertyValue = container;
