《Effective C#》笔记 C#中的动态编程

Dynamic Programming in C#

动态类型可加速开发的过程，更易于与其它的系统进行交互，静态类型在运行时的执行效率更高；

在C#中绝大多数情况下使用静态类型。在某些时候使用动态类型会更加高效，C#也提供了动态类型编程的支持；

38 理解动态类型的优劣

泛型的一个限制就是，如果想访问定义在System.Object之外的方法，就必须给出约束。泛型的约束可以限制为基类、一系列的接口、值类型/引用类型、存在公有的无参构造函数等。约束无法定义必须存在某个方法。如果需要创建一个通用的操作如“ + ”时，这个限制会让人无所适从，而使用动态调用则可以解决此类问题；

动态类型的一个示例。只要求在运行时两个对象存在可用的“ + ”操作即可：

public static dynamic Add(dynamic left, dynamic right)
{
    return left + right;
}

在编译期，动态变量仅拥有那些定义于System.Object中的方法，编译器会添加必要的代码让每个成员访问都以动态调用的方式进行。在运行时，代码将检查该对象并判断将要执行的方法是否存在，只要所需要的成员在运行时存在，那么即可正常工作。上边的 Add 方法不仅可用于两个数的相加，还可以用于字符串拼接，甚至将DataTime和TimeSpan相加，只要两个对象之间存在“ + ”操作符即可；

动态类型的缺点在于它抛弃了类型系统的安全性，并限制了编译器能够提供的辅助功能，所有与类型解释相关的问题只能在运行时才能发现；

动态类型要想被其它大多数代码使用，需要将其转换为静态类型，如：

// dynamic answer = ...

answer = Add(5, 12.3);
int value = (int)answer;
string stringLabel = System.Convert.ToString(answer);

使用表达式树（Expression Tree）也不需要在编译期知道类型，这是在运行时创建代码的另一种方法（lambda表达式和函数式编程都需要编译器的类型）。以下是使用表达式方法版本的 Add 方法，在真正的 + 操作前，会把两个操作数都转换为返回值类型：

public static TResult AddExpressionWithConversion<T1, T2, TResult>(T1 left, T2 right)
{
    var leftOperand = Expression.Parameter(typeof(T1), "left");
    Expression convertedLeft = leftOperand;
    if (typeof(T1) != typeof(TResult))
    {
        convertedLeft = Expression.Convert(leftOperand,
            typeof(TResult));
    }
    var rightOperand = Expression.Parameter(typeof(T2), "right");
    Expression convertedRight = rightOperand;
    if (typeof(T2) != typeof(TResult))
    {
        convertedRight = Expression.Convert(rightOperand,
        typeof(TResult));
    }
    var body = Expression.Add(convertedLeft, convertedRight);
    var adder = Expression.Lambda<Func<T1, T2, TResult>>(body, leftOperand, rightOperand);
    return adder.Compile()(left, right);
}

对于返回值类型和操作数类型不相同的情况，则需要更进一步增加代码来确保类型，这么做的话基本等于是重新实现了C#中处理动态分发的代码（条目41），此时使用动态类型会更好；

一个建议是：当操作数和返回值为同一类型时，应该使用表达式。这样既能提供泛型类型的参数，又能降低运行时出错的可能。以下是使用表达式实现运行时分发的建议版本：

public static class BinaryOperators<T>
{
    static Func<T, T, T> compiledExpression;
    public static T Add(T left, T right)
    {
        if (compiledExpression == null)
            createFunc();
        return compiledExpression(left, right);
    }
    private static void createFunc()
    {
        var leftOperand = Expression.Parameter(typeof(T), "left");
        var rightOperand = Expression.Parameter(typeof(T), "right");
        var body = Expression.Add(leftOperand, rightOperand);
        var adder = Expression.Lambda<Func<T, T, T>>(body, leftOperand, rightOperand);
        compiledExpression = adder.Compile();
    }
}

使用动态类型和在运行时创建表达式树都会带来性能上的影响。大多数情况下，使用动态类型会比使用反射手工实现延迟绑定更加高效。如果能使用静态类型解决问题，那么一定会比使用动态类型更加高效；

40 将接受匿名类型的参数声明为dynamic

当你需要操作可能带有同样属性名称的不同匿名类型，且这些类型不属于你的核心应用程序，你又因为各种原因不能创建具名类型时，考虑使用dynamic这个类型来绕开这些限制。动态类型支持运行时绑定，还会让编译器生成所有必须的代码，以便配合运行时出现的各种可能类型；

一个示例：现在需要打印出一张价格单的信息，价格单中的信息来自多个不同的数据库，其中的商品product对象定义方式不同，既不会有共同的基类，也不会实现同一个接口。此时可以考虑使用适配器模式，也可以使用基于动态类型的方法：

public static void WritePricingInformation(dynamic product)
{
    Console.WriteLine("The price of one {0} is {1}",
        product.Name, product.Price);
}

还需要创建一个匿名类型，给出上边方法中所需要的属性名称，并用从任意一个数据源中查询的数据填充，

1
2
3

var price = from n in Inventory
            where n.Cost > 20
            select new { n.Name, Price = n.Cost * 1.15M };

这里可以使用任何必要的类型转换操作，只要生成的匿名类型中包括 Price 和 Name 两个属性即可；除此之外也可以包含其它额外的属性信息。对于静态类型，如果这个静态类型中包含了属性 Price 和 Name ，就也可以在 WritePricingInformation 中使用（类型不相符也不会有问题，例如匿名类型中 Price 类行为decimal而使用的静态类型中 Price 为double，不会有问题）；

大量使用动态类型，会带来额外性能开销。一种做法是为 WritePricingInformation 方法提供重载，用于特定的商品静态类型：

public class Product
{
    public decimal Cost { get; set; }
    public string Name { get; set; }
    public decimal Price
    {
        get { return Cost * 1.15M; }
    }
}

// Derived Product class:
public class SpecialProduct : Product
{
    public string ReasonOnSpecial { get; set; }
    // other methods elided
}

// elsewhere
public static void WritePricingInformation(dynamic product)
{
    Console.WriteLine("The price of one {0} is {1}",
        product.Name, product.Price);
}

public static void WritePricingInformation(Product product)
{
    Console.WriteLine("In type safe version");
    Console.WriteLine("The price of one {0} is {1}",
        product.Name, product.Price);
}

这么做之后，对于任何 Product 和 SpecialProduct 或二者的衍生类，都会使用静态类型版本，而其它对象（含匿名对象）编译器会选择动态类型的版本。在内部实现中，动态绑定将用各种方法缓存下你常用的方法，以尽可能降低开销，某个方法绑定在第一次调用执行之后，后续的每个调用都会直接重用它，此举虽不能完全避免开销，但动态实现也已经尽可能地降低了动态所带来的代价；

41 用DynamicObject或IDynamicMetaObjectProvider实现数据驱动的动态类型

C#通过动态类型、 System.Dynamic.DynamicObject 基类和 System.Dynamic.IDynamicMetaObjectProvider 接口来创建带有动态功能的类型，类型的公有接口可以在运行时改变；

最简单的方法是继承于 System.Dynamic.DynamicObject 。以下是一个示例，创造一个名为 DynamicPropertyBag 的动态类型，可以获取和设置它的属性，如下所示：

dynamic dynamicProperties = new DynamicPropertyBag();
try
{
    Console.WriteLine(dynamicProperties.Marker);
}
catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException)
{
    Console.WriteLine("There are no properties");
}
dynamicProperties.Date = DateTime.Now;
dynamicProperties.Name = "Bill Wagner";
dynamicProperties.Title = "Effective C#";
dynamicProperties.Content = "Building a dynamic dictionary";

上边的 DynamicPropertyBag 类应当这样定义，继承于 DynamicObject ，覆写 TrySetMember 和 TryGetMember 方法：

class DynamicPropertyBag : DynamicObject
{
    private Dictionary<string, object> storage =
        new Dictionary<string, object>();
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        if (storage.ContainsKey(binder.Name))
        {
            result = storage[binder.Name];
            return true;
        }
        result = null;
        return false;
    }
    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        string key = binder.Name;
        if (storage.ContainsKey(key))
            storage[key] = value;
        else
            storage.Add(key, value);
        return true;
    }
    public override string ToString()
    {
        StringWriter message = new StringWriter();
        foreach (var item in  storage)
            message.WriteLine("{0}:\t{1}", item.Key, item.Value);
        return message.ToString();
    }
}

DynamicObject 包含了用来处理索引器、方法、构造函数、一元和二元操作符的调用的相关方法。覆写这些方法来创建更适合需要的动态对象。返回的布尔值表示你的重载是否处理了本次请求；

使用动态类型可以简化对xml对象的访问，将类型用数据驱动，使用点（ . ）和元素名称来逐层深入访问xml对象；

有的时候，动态类型必须要继承于其它的基类，即无法继承 DynamicObject ，此时可以选择实现接口 IDynamicMetaObjectProvider 。实现该接口需要实现 GetMetaObject() 方法，以下是一个示例：

class DynamicDictionary2 : IDynamicMetaObjectProvider
{
    #region IDynamicMetaObjectProvider Members
    DynamicMetaObject IDynamicMetaObjectProvider.
        GetMetaObject(
            System.Linq.Expressions.Expression parameter)
    {
        return new DynamicDictionaryMetaObject(parameter,
            this);
    }
    #endregion
    
    private Dictionary<string, object> storage = new
        Dictionary<string, object>();
        
    public object SetDictionaryEntry(string key,
        object value)
    {
        if (storage.ContainsKey(key))
            storage[key] = value;
        else
            storage.Add(key, value);
        return value;
    }
        
    public object GetDictionaryEntry(string key)
    {
        object result = null;
        if (storage.ContainsKey(key))
        {
            result = storage[key];
        }
        return result;
    }
    
    public override string ToString()
    {
        StringWriter message = new StringWriter();
        foreach (var item in storage)
            message.WriteLine("{0}:\t{1}", item.Key,
                item.Value);
        return message.ToString();
    }
}

调用 GetMetaObject 时会返回一个新的 DynamicDictionaryMetaObject 对象，且 GetMetaObject 会在每次访问 DynamicDictionary2 的成员时被调用，即便是 DynamicDictionary2 中提供了静态定义的方法，因为需要解析这些方法来唤醒可能出现的动态行为；

使用动态对象编程较为复杂，表达式树很难调试也很难保证正确性。编写动态对象的代码时需要注意效率和性能，使用动态类型会带来性能上的损失，而手工实现所带来的损失往往会更大一些。

42 如何使用表达式API

在运行时基于反射检查代码或创建代码的功能非常强大，但是太过底层且难用，可以使用表达式和表达式树作为替代方案。以下会有两个示例：

第一个例子是通过解析表达式将代码转换成能实现运行时算法的数据元素。在通信框架中常常会使用某种代码生成工具来为特定的服务生成客户端的代理。 ClientProxy<T> 了解如何将方法和各个参数转换成最终的调用，不过它实际上并不了解所访问的服务，调用方式如下：

1
2
3

var client = new ClientProxy<IService>();
var result = client.CallInterface<string>(
    srver => srver.DoWork(172));

ClientProxy<T> 没有使用老式的代码生成器，而是使用表达式树和泛型来判断调用了哪个方法以及使用了哪些参数。重点就在这个 CallInterface 方法，这里其实并不需要实现了 IService 接口的实例对象：

public TResult CallInterface<TResult>(Expression<
    Func<T, TResult>> op)
{
    var exp = op.Body as MethodCallExpression;
    var methodName = exp.Method.Name;
    var methodInfo = exp.Method;
    var allParameters = from element in exp.Arguments
                            select processArgument(element);
    Console.WriteLine("Calling {0}", methodName);
    foreach (var parm in allParameters)
        Console.WriteLine(
            "\tParameter type = {0}, Value = {1}",
            parm.Item1, parm.Item2);
    return default(TResult);
}

private Tuple<Type, object> processArgument(Expression
    element)
{
    object argument = default(object);
    LambdaExpression l = Expression.Lambda(
        Expression.Convert(element, element.Type));
    Type parmType = l.ReturnType;
    argument = l.Compile().DynamicInvoke();
    return Tuple.Create(parmType, argument);
}

方法 processArgument 将每个参数当作表达式来求值，这里只需要在表达式中提供一个定义在服务器端的一个成员方法即可；

第二个例子是在运行时生成代码。比如在一个大型的系统中，用于将不同子系统中的不同类型互相转换，代码类似于这样：

1
2
3

var converter = new Converter<SourceContact,
    DestinationContact>();
DestinationContact dest2 = converter.ConvertFrom(source);

实现的功能是这样的：将源对象中公有的 get 访问器且目标类型中有公有的同名的 set 访问器的属性值逐一复制，即实现类似这样的功能（并非合法的C#代码，仅用来解释）：

TDest ConvertFromImaginary(TSource source)
{
    TDest destination = new TDest();
    foreach (var prop in sharedProperties)
        destination.prop = source.prop;
    return destination;
}

为了实现上边的伪代码，我们需要创建一个表达式，完整的代码如下（实现前边的 converter ）：

private void createConverterIfNeeded()
{
    if (converter == null)
    {
        var source = Expression.Parameter(typeof(TSource),
            "source");
        var dest = Expression.Variable(typeof(TDest),
            "dest");
        var assignments = from srcProp in
                        typeof(TSource).GetProperties(
                            BindingFlags.Public |
                            BindingFlags.Instance)
                        where srcProp.CanRead
                        let destProp = typeof(TDest).
                            GetProperty(
                            srcProp.Name,
                            BindingFlags.Public |
                            BindingFlags.Instance)
                        where (destProp != null) &&
                            (destProp.CanWrite)
                        select Expression.Assign(
                            Expression.Property(dest,
                                destProp),
                            Expression.Property(source,
                                srcProp));
        
        // put together the body:
        var body = new List<Expression>();
        body.Add(Expression.Assign(dest,
            Expression.New(typeof(TDest))));
        body.AddRange(assignments);
        body.Add(dest);
        var expr =
            Expression.Lambda<Func<TSource, TDest>>(
                Expression.Block(
                new[] { dest }, // expression parameters
                body.ToArray() // body
                ),
                source  // lambda expression
            );
        
        var func = expr.Compile();
        converter = func;
    }
}

代码中涉及的主要步骤如下：

源和目标的参数表达式，


     source

和


     dest

；

筛选满足条件的属性，


     srcProp

和


     destProp

；

赋值，使用


     Expression.Assign

；

组装成表达式的主体部分，是一个


     List<Expression>

；

创建lambda表达式


     expr

；

编译成一个委托，赋值给


     converter

；

43 使用表达式将延迟绑定转换为预先绑定

延迟绑定API需要使用符号（symbol）信息来实现，而预先编译好的API则无需这些信息，因为编译器已经解释了符号引用。表达式API可以在二者之间架起桥梁。表达式对象包含了一种抽象的符号树，用于表示想要执行的算法。你可以使用表达式API执行那些代码，也可以检查所有的符号，包括变量、方法和属性的名称等。你可以使用表达式API创建强类型的、编译后的方法，与系统中依赖延迟绑定的部分交互，并使用属性或其他符号的名称；

还是拿一个例子来说明。首先是延迟绑定的例子，在Silverlight和WPF中使用的属性通知接口，需要支持对绑定属性变化的响应，以便让用户界面元素能够在底层数据该懂事做出更新，需要实现两个接口， INotifyPropertyChanged 和 INotifyPropertyChanging 。接口的实现很简单，每个里边定义了一个事件，事件的参数也只是简单地包含了发生变化的属性的名称，以下是一个示例：

public class MemoryMonitor : INotifyPropertyChanged,
        INotifyPropertyChanging
{
    System.Threading.Timer updater;
    public MemoryMonitor()
    {
        updater = new System.Threading.Timer((_) =>
            timerCallback(_),
            null, 0, 5000);
    }
    
    private void timerCallback(object unused)
    {
        UsedMemory = GC.GetTotalMemory(false);
    }
    
    public long UsedMemory
    {
        get { return mem; }
        private set
        {
            if (value != mem)
            {
                if (PropertyChanging != null)
                    PropertyChanging(this,
                        new PropertyChangingEventArgs(
                        "UsedMemory"));
                mem = value;
                if (PropertyChanged != null)
                    PropertyChanged(this,
                        new PropertyChangedEventArgs(
                        "UsedMemory"));
            }
        }
    }
    
    private long mem;
    
    #region INotifyPropertyChanged Members
    public event PropertyChangedEventHandler
        PropertyChanged;
    #endregion
    #region INotifyPropertyChanging Members
    public event PropertyChangingEventHandler
        PropertyChanging;
    #endregion
}

代码如上。问题在于，每次实现这个接口时都要重复这么一段冗长的代码，每个属性的setter都要触发事件（变化前和变化后），并且事件参数中使用字符串来表示属性的名字。为了解决这些问题，可以借助扩展方法来实现，主要分为以下几步：

查看新的值和旧的值是否有差别；

触发


     INotifyPropertyChanging

的事件；

触发


     INotifyPropertyChanged

的事件；

为了增强代码的健壮性，应避免使用属性名称的字符串来硬编码。我们可以使用扩展方法来扩展 PropertyChanged 事件，改为类似下边这样的实现形式：

// MemoryMonitor, using the extension methods
private void timerCallback(object unused)
{
    long updatedValue = GC.GetTotalMemory(false);
    PropertyChanged.SetNotifyProperty(updatedValue,
        () => UsedMemory);
}

public long UsedMemory
{
    get;
    private set;
}

这使 MemoryMonitor 的实现大大简化，避免了使用硬编码字符串， UsedMemory 是一个自动的隐式属性，代码中也无需做复杂的逻辑。但是实现这些功能的代码稍微有点复杂，其中使用了反射和表达式树，下面是完整的扩展方法实现：

public static class PropertyNotifyExtensions
{
    public static T SetNotifyProperty<T>(this
        PropertyChangedEventHandler handler,
        T newValue, Expression<Func<T>> oldValueExpression,
            Action<T> setter)
    {
        return SetNotifyProperty(handler, null, newValue,
            oldValueExpression, setter);
    }
    
    public static T SetNotifyProperty<T>(this
        PropertyChangedEventHandler postHandler,
        PropertyChangingEventHandler preHandler,
        T newValue, Expression<Func<T>> oldValueExpression,
        Action<T> setter)
    {
        Func<T> getter = oldValueExpression.Compile();
        T oldValue = getter();
        if (!oldValue.Equals(newValue))
        {
            var body = oldValueExpression.Body as
                System.Linq.Expressions.MemberExpression;
            var propInfo = body.Member as PropertyInfo;
            string propName = body.Member.Name;
            // Get the target object
            var targetExpression = body.Expression as
                ConstantExpression;
            object target = targetExpression.Value;
            if (preHandler != null)
                preHandler(target, new
                PropertyChangingEventArgs(propName));
            // Use Reflection to do the set:
            // propInfo.SetValue(target, newValue, null);
            //var compiledSetter = setter.Compile();
            setter(newValue);
        
            if (postHandler != null)
                postHandler(target, new
                PropertyChangedEventArgs(propName));
        }
        return newValue;
    }
}