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

  静态类型和动态类型各有所长,静态类型能够让编译器帮你找出更多的错误,因为编译器能够在编译时进行大部分的检查工作。C# 是一种静态类型的语言,不过它加入了动态类型的语言特性,可以更高效地解决问题。  

一、目录

  • 三十八、理解动态类型的优劣
  • 三十九、使用动态类型表达泛型类型参数的运行时类型
  • 四十、将接受匿名类型的参数声明为 dynamic
  • 四十一、用 DynamicObject 或 IDynamicMetaObjectProvider 实现数据驱动的动态类型
  • 四十二、如何使用表达式 API
  • 四十三、使用表达式将延迟绑定转换为预先绑定
  • 四十四、尽量减少在公有 API 中使用动态类型

三十八、理解动态类型的优劣

  1. C# 动态类型是为了让静态代码能够更加平滑地与其他使用动态类型的环境进行交互,而不是鼓励在一般场景中使用 dynamic 进行动态编程。

  2. 只要对象在运行时包含成员,那么即可正常使用。

  3. 若是一个操作数(包括 this)为动态类型,那么返回结果也会是动态类型。不过,最后依然要转换成静态类型,以便被其它 C# 代码所使用,以及被编译器感知。

  4. 当你需要不知道具体类型的运行时解析方法的时候,动态类型是最佳的工具。如果你能在编译期间明确类型,那么可以使用 lambda 表达式和函数式编程来解决问题。

  5. 表达式树,一种在运行时创建代码的方法(下面提供示例)。

  6. 大多数情况,可以使用 Lambda 表达式创建泛型 API,让调用者自己动态定义所需要执行的代码即可。

  7. 优先使用静态类型,静态类型比动态类型更高效,动态类型和在运行时创建表达式树都会带来性能上的影响,即便这点影响微不足道。

  8. 若你能控制程序中所有涉及的类型时,可以引入一个接口,而不是动态类型,即基于接口编程,并让所有需要支持该接口行为的类型都实现该接口。通过 C# 类型系统可以减少代码在运行时所产生的错误,编译器也能够生成更加高效的代码。

  9. 动态类型做法的效率比纯粹的静态类型下降挺大,但实现的难度却比解析表达式树要简单地挺多。

  这里,我使用 3 种数字相加的方法,dynamic 动态、Func 委托以及使用表达式树进行相加的区别:

        [TestMethod]
public void Test()
{
var result1 = AddDynamic(, );
Console.WriteLine((int)result1); var result2 = AddFunc(, , (x, y) => x + y);
Console.WriteLine(result2); var result3 = AddExpressionTree(, );
Console.WriteLine(result3);
} /// <summary>
/// Add,动态
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private dynamic AddDynamic(dynamic a, dynamic b)
{
return a + b;
} /// <summary>
/// Add,使用委托
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="TR"></typeparam>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="func"></param>
/// <returns></returns>
private TR AddFunc<T1, T2, TR>(T1 a, T2 b, Func<T1, T2, TR> func)
{
return func(a, b);
} /// <summary>
/// Add,使用表达式树
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private T AddExpressionTree<T>(T a, T b)
{
ParameterExpression leftOperand = Expression.Parameter(typeof(T), "left");
ParameterExpression rightOperand = Expression.Parameter(typeof(T), "right");
BinaryExpression body = Expression.Add(leftOperand, rightOperand);
Expression<Func<T, T, T>> adder = Expression.Lambda<Func<T, T, T>>(body, leftOperand, rightOperand); Func<T, T, T> theDelegate = adder.Compile();
return theDelegate(a, b);
}
}

三十九、使用动态类型表达泛型类型参数的运行时类型

  1. System.Linq.Enumerable.Cast<T> 将序列中的对象转换成 T,从而使得 LINQ 可以配合 IEnumerable 进行工作。

  2. Convert<T> 要比 Cast<T> 适用性更广,但同时也会执行更多的工作。

四十、将接受匿名类型的参数声明为 dynamic

  1. 不要过度使用动态类型,因为动态调用会增加系统的额外开销,即便不大。

  2. 长远来看,具体类型更易于维护,编译器和类型系统也会为其提供更好的支持。

  3. 扩展方法不能基于动态对象定义。

四十一、用 DynamicObject 或 IDynamicMetaObjectProvider 实现数据驱动的动态类型

  1. 创建带有动态功能的类型的最简单的方法就是继承 System.Dynamic.DynamicObject。若能直接继承 DynamicObject,那么创建动态类就会比较简单。

  2. 实现 IDynamicMetaObjectProvider 就意味着需要实现方法 GetmetaObject()。

  3. 创建动态类型时首选继承,如果必须使用其他基类,可以手工实现 IDynamicMetaObjectProvider 接口,虽然所有的动态类型都会带来性能上的损失,但这种手工实现接口的方式所带来的损失往往更大一些。

  这是一个实现动态类型模型的一个示例。除了需要继承 DynamicObject,还需要重写 TryGetMemebr() 和 TrySetMemebr()。

        [TestMethod]
public void Test1()
{
dynamic propDynamic = new DynamicPropertyBag();
propDynamic.Now = DateTime.Now; Console.WriteLine(propDynamic.Now);
} /// <summary>
/// 动态属性绑定模型
/// </summary>
internal class DynamicPropertyBag : DynamicObject
{
private readonly Dictionary<string, object> _storage = new Dictionary<string, object>(); /// <summary>
/// 获取属性值
/// </summary>
/// <param name="binder"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
var key = binder.Name; if (_storage.ContainsKey(key))
{
result = _storage[key];
return true;
} result = null;
return false;
} /// <summary>
/// 设置属性值
/// </summary>
/// <param name="binder"></param>
/// <param name="value"></param>
/// <returns></returns>
public override bool TrySetMember(SetMemberBinder binder, object value)
{
var key = binder.Name; try
{
if (_storage.ContainsKey(key))
{
_storage[key] = value;
}
else
{
_storage.Add(key, value);
} return true;
}
catch (Exception e)
{
Console.WriteLine(e);
return false;
}
}

四十二、如何使用表达式 API

  1. 传统的反射 API 可以用表达式和表达式树进行更好的替代,表达式可以直接编译为委托。

  2. 接口使我们可以得到一个更为清晰、也更具可维护性的系统,反射是一个很强大的晚期绑定机制(虽然效率有所降低),.NET 框架使用它来实现 Windows 控件和 Web 控件的数据绑定。

  这里提供了一个示例:

        [TestMethod]
public void Test2()
{
var result = Call<int, string>((x) => (x * ).ToString("D")); Console.WriteLine(result);
} /// <summary>
/// 调用
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="op"></param>
/// <returns></returns>
private TResult Call<T, TResult>(Expression<Func<T, TResult>> op)
{
var exp = op.Body as MethodCallExpression;
var result = default(TResult); if (exp == null)
{
return result;
} var methodName = exp.Method.Name;
var parameters = exp.Arguments.Select(ProcessArgument); Console.WriteLine($"方法名 {methodName}"); foreach (var parameter in parameters)
{
Console.WriteLine("参数:");
Console.WriteLine($"\t{parameter.Item1}:{parameter.Item2}");
} return result;
} /// <summary>
/// 处理参数
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
private Tuple<Type, object> ProcessArgument(Expression expression)
{
object arg = default(object);
LambdaExpression l = Expression.Lambda(Expression.Convert(expression, expression.Type)); Type parmType = l.ReturnType;
arg = l.Compile().DynamicInvoke(); return Tuple.Create(parmType, arg);
}

四十三、使用表达式将延迟绑定转换为预先绑定

  1. 延迟绑定API要使用符号(symbol)信息来实现,而预先编译好的 API 则无需这些信息,表达式 API 正是二者之间的桥梁。

  2. 延迟绑定常见于 Silverlight 和 WPF 中使用的属性通知接口,通过实现 INotifyPropertyChanged 和 INotifyPropertyChanging 接口来实现属性变更的预绑定。

四十四、尽量减少在公有 API 中使用动态类型

  1. 优先使用 C# 的静态类型,并尽可能地降低动态类型的作用范围。若是想一直使用动态特性,你应该直接选用一种动态语言,而非 C#。

  2. 若要在程序中使用动态特性,请尽量不要在公有接口中使用,这样会将动态类型限制在一个单独的对象(或类型)中。

本系列

  《Effective C#》快速笔记(一)- C# 语言习惯

  《Effective C#》快速笔记(二)- .NET 资源托管

  《Effective C#》快速笔记(三)- 使用 C# 表达设计

  《Effective C#》快速笔记(四) - 使用框架

  《Effective C#》快速笔记(五) - C# 中的动态编程

  《Effective C#》快速笔记(六) - C# 高效编程要点补充


【博主】反骨仔

【原文】http://www.cnblogs.com/liqingwen/p/6816100.html

【GitHub】https://github.com/liqingwen2015/XMind 可以下载 XMind

【参考】《Effective C#》

【参考】http://blog.csdn.net/w174504744/article/details/50562109

[.NET] 《Effective C#》快速笔记 - C# 中的动态编程的更多相关文章

  1. 《Effective C#》快速笔记(五)- - C# 中的动态编程

    静态类型和动态类型各有所长,静态类型能够让编译器帮你找出更多的错误,因为编译器能够在编译时进行大部分的检查工作.C# 是一种静态类型的语言,不过它加入了动态类型的语言特性,可以更高效地解决问题. 一. ...

  2. C# Note22: 《Effective C#》笔记

    参考:<Effective C#>快速笔记(一)- C# 语言习惯 参考:<Effective C#>快速笔记(二)- .NET 资源托管 参考:<Effective C ...

  3. [.NET] 《Effective C#》快速笔记(四)- 使用框架

    <Effective C#>快速笔记(四)- 使用框架 .NET 是一个类库,你了解的越多,自己需要编写的代码就越少. 目录 三十.使用重写而不是事件处理函数 三十一.使用 ICompar ...

  4. [.NET] 《Effective C#》快速笔记 - C# 高效编程要点补充

    <Effective C#>快速笔记 - C# 高效编程要点补充 目录 四十五.尽量减少装箱拆箱 四十六.为应用程序创建专门的异常类 四十七.使用强异常安全保证 四十八.尽量使用安全的代码 ...

  5. [.NET] 《Effective C#》快速笔记(二)- .NET 资源托管

    <Effective C#>快速笔记(二)- .NET 资源托管 简介 续 <Effective C#>读书笔记(一)- C# 语言习惯. .NET 中,GC 会帮助我们管理内 ...

  6. [.NET] 《Effective C#》快速笔记(一)- C# 语言习惯

    <Effective C#>快速笔记(一)- C# 语言习惯 目录 一.使用属性而不是可访问的数据成员 二.使用运行时常量(readonly)而不是编译时常量(const) 三.推荐使用 ...

  7. 《Effective C#》快速笔记(一)- C# 语言习惯

    目录 一.使用属性而不是可访问的数据成员 二.使用运行时常量(readonly)而不是编译时常量(const) 三.推荐使用 is 或 as 操作符而不是强制类型转换 四.使用 Conditional ...

  8. 《Effective C#》快速笔记(六)- - C# 高效编程要点补充

    目录 四十五.尽量减少装箱拆箱 四十六.为应用程序创建专门的异常类 四十七.使用强异常安全保证 四十八.尽量使用安全的代码 四十九.实现与 CLS 兼容的程序集 五十.实现小尺寸.高内聚的程序集 这是 ...

  9. 《Effective C#》快速笔记(四)- 使用框架

    .NET 是一个类库,你了解的越多,自己需要编写的代码就越少. 目录 三十.使用重写而不是事件处理函数 三十一.使用 IComparable<T> 和 IComparer<T> ...

随机推荐

  1. Python的字典dictionary

    创建: dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};删除: del dict['Name']; # 删除键是'Name'的条目 dict.c ...

  2. 深入浅出数据结构C语言版(5)——链表的操作

    上一次我们从什么是表一直讲到了链表该怎么实现的想法上:http://www.cnblogs.com/mm93/p/6574912.html 而这一次我们就要实现所说的承诺,即实现链表应有的操作(至于游 ...

  3. 【树莓派】树莓派下WiFi断线自动重连

    实现 WiFi 断线自动重连.原理是用 Python 监测网络是否断线,如果断线则重启网络服务. 1.Python 代码 autowifi.py,放在 /home/pi 目录下: #!/usr/bin ...

  4. 读书笔记 effective c++ Item 36 永远不要重新定义继承而来的非虚函数

    1. 为什么不要重新定义继承而来的非虚函数——实际论证 假设我告诉你一个类D public继承类B,在类B中定义了一个public成员函数mf.Mf的参数和返回类型并不重要,所以假设它们都是void. ...

  5. 老司机实战Windows Server Docker:4 单节点Windows Docker服务器简单运维(下)

    上篇中,我们主要介绍了使用docker-compose对Windows Docker单服务器进行远程管理,编译和部署镜像,并且设置容器的自动启动.但是,还有一些重要的问题没有解决,这些问题不解决,就完 ...

  6. Logistic Regression理论总结

    简述: 1. LR 本质上是对正例负例的对数几率做线性回归,因为对数几率叫做logit,做的操作是线性回归,所以该模型叫做Logistic Regression. 2. LR 的输出可以看做是一种可能 ...

  7. iOS开发之UINavigationController

    1.概述: 利用UINavigationController,可以轻松地管理多个控制器,轻松完成控制器之间的切换,典型例子就是系统自带的“设置”应用. 2.UINavigationController ...

  8. 实现标签的添加与删除(tags)

    在项目中会遇到,标签(tags)的添加与去除的需求 demo:我们有 tags   '专利','商标','版权','域名' demand:在发布内容的时候,要求可以添加tag,(实现tag的增加与删除 ...

  9. gcc编译参数之m32 m64

    m32指定编译为32位应用程序: make CFLAGS=-m32 m64指定编译为64位应用程序: make CFLAGS=-m64

  10. 前端jquery validate表单验证框架的使用

    一.框架本身校验方法的扩展 建议写在页内用于扩展框架本身的一些校验方法, 使用频繁也可以直接在源码上修改 例如扩展手机号码的校验: /*手机号码验证扩展 最新的号码 mobile: class的表示 ...