aspnetwinform
aspnetwinform

WPF基础到企业应用系列8——依赖属性之“风云再起”

一. 摘要

　　首先圣殿骑士很高兴”WPF 基础到企业应用系列” 能得到大家的关注、支持和认可。看到很多朋友留言希望加快速度的问题，我会尽力的，对你们的热情关注也表示由衷的感谢。这段时间更新慢的主要原因是因为忙着用TDD还原MONO的框架，同时也因为一直在研究云计算，所以就拖拖拉拉一直没有发布后面的文章。由于WPF整个系列是自己的一些粗浅心得和微薄经验，所以不会像写书那么面面俱到，如果有不足或者错误之处也请大家见谅。在今年之内圣殿骑士会尽量完成”WPF 基础到企业应用系列”和”云计算之旅系列“，诚然，由于本人才识浅薄，所以热切希望和大家共勉！

　　由于依赖属性是WPF和Silverlight的核心概念，微软在C\S和B\S平台上主要精力都放到了WPF和Silverlight技术上，同时Silverlight也是Windows Phone的两大编程模型之一（另外一种是XNA），所以我们花费了大量的时间和篇幅进行论述。在上一篇WPF基础到企业应用系列7——深入剖析依赖属性中，我们首先从依赖属性基本介绍讲起，然后过渡到依赖属性的优先级、附加属性、只读依赖属性、依赖属性元数据、依赖属性回调、验证及强制值、依赖属性监听、代码段(自动生成) 等相关知识，最后我们模拟一个WPF依赖属性的实现，由于上篇是根据微软WPF的BCL源码剖析的，所以这篇我们就研究一下.NET的跨平台版本MONO，看下它是怎么来实现这个依赖属性机制。

二. 本文提纲

· 1.摘要

· 2.本文提纲

· 3.兵马未动、废话先行

· 4.依赖属性续前缘

· 5.引入测试驱动开发

· 6.DependencyProperty测试代码

· 7.DependencyProperty实现代码

· 8.DependencyObject测试代码

· 9.DependencyObject实现代码

· 10.PropertyMetadata测试代码

· 11.PropertyMetadata实现代码

· 12.其他协助类测试代码

· 13.其他协助类的实现代码

· 14.回归并统计覆盖率

· 15.简单验证依赖属性系统

· 16.本文总结

· 17.相关代码下载

· 18.系列进度

三. 兵马未动，废话先行

在讲这篇文章之前，我们先来拉一拉家常，说点题外话，就当进入正餐之前的一些甜点，当然这里主要针对.NET平台而言：

1，浅谈软件技术的发展趋势及定位

　　互联网的普及应用催生了很多技术的发展与更新，如果仔细深究，你会发现软件技术的发展趋势将主要体现在以下四个方面：客户端软件开发（其中包括客户端软件、游戏、中间件和嵌入式开发等）、Web 开发（包括传统的Web技术、Web游戏以及一些在线应用）、移动设备软件开发（主要涉及到手机等移动设备）、云计算开发（公有云、私有云、混合云会逐渐界限清晰，云厂商以及云平台也会逐渐整合和成熟起来）。就微软来说，这四个方面主要如下：

◆ 客户端软件开发

　　目前微软主要有Win32 应用程序、MFC 应用程序、WinForm应用程序和WPF 应用程序作为开发选择，目前这四种技术还会共存，因为不同的需求以及不同的人群都有不同的需要。当然WPF借助于其强大的功能和迅猛的发展速度很快会成为首选，这个是值得肯定的。

◆ Web 开发

　　在WEB方面微软主要有ASP.NET、ASP.NET MVC、Silverlight三种技术，ASP.NET技术已经发展了多年，在未来的很长一段时间内还会是主流，同时结合Silverlight作为局部和整体应用效果都还很不错，所以这也是很多企业的首选。ASP.NET MVC在目前来说应用还不是特别广泛，不过用过之后感觉也还不错，只是还需要一段时间的适应过程而已。Silverlight在构建局部应用和整站应用都发挥了不错的优势，在Windows Phone中也表现得不错，所以这个技术将会一直热下去。

◆ 移动设备软件开发

　　移动设备方面可谓是现在众厂商竞争最激烈的市场之一，也是传统技术和新型技术的主要战场之一。微软现在主推的Windows Phone开发主要包括Silverlight和XNA两种技术，Windows Phone开发逐渐变得和ASP.NET开发一样简单，这也是微软的一个目标。

◆ 云计算开发

　　云计算现在基本上成了互联网的第一大热门词，不管是软件为主导的企业，还是以硬件为主导的企业，都卷入了这场纷争与革命。微软的云平台——Windows Azure Platform，它是微软完整的云计算平台，目前包含了如下三大部分（Windows Azure：运行在云中的操作系统，对于用户来说是虚拟且透明的，其中提供了Compute(计算)，Storage(存储)，以及Manage(管理)这三个主要功能及其底层服务，使用起来相当的便捷。SQL Azure：运行于云中的一个关系数据库，和SQL Server 2008类似，但是在功能上还没有那么强大。AppFabric：全名是Windows Azure platform AppFabric，提供了访问控制、服务总线等服务，主要用于把基础应用连接到云中）。

其实把这四个方面总结起来就是传说中的微软“三屏一云”战略，从中也可以看出微软逍遥于天地，纵横于宇内，啸傲于世间，雄霸于大地的枭雄战略！

2，浅谈微软跨平台与MONO

　　在谈之前我们先看一下什么是MONO？MONO项目是由Ximian发起、Miguel de lcaza领导、Novell公司主持的项目。它是一个致力于开创.NET在Linux，FreeBSD，Unix，Mac OS X和Solaris等其他平台使用的开源工程。它包含了一个C#语言的编译器，一个CLR的运行时，和一组类库，并逐渐实现了 ADO.NET、ASP.NET、WinForm、Silverlight（可惜没有实现强大的WPF），能够使得开发人员在其他平台用C#开发程序。

◆ 值得看好的地方：

1，跨平台：开创.NET在Linux，FreeBSD，Unix，Mac OS X和Solaris等其他平台使用，这是微软没有实现的，但是MONO进行了补充，所以值得看好。

2，开源：不论使用什么技术，大家似乎都希望能够用开源的产品，一方面是考虑到技术的可控性和可维护性；另一方面则是考虑到安全性，当然在另一个角度也是可以学习到其中的一些技术和思想，所以大家对开源总是报以欢迎的态度。

3，不同的方式实现.NET框架：由于微软对技术申请了专利，所以MONO不能盲目的模仿，对很多细节都改用自己的方式进行了实现，所以我们也可以学到很多不一样的实现方式。

4，持续更新：MONO从一开始到现在始终在更新，其中包括bug修复、版本升级、增加新的功能及应用，所以相信它会在不断的更新中更加完善。

◆ 不足之处：

1.模仿但要避免专利：由于是模仿微软.NET平台，但因为微软对代码申请了专利，所以MONO只能采用其它实现方式来实现同样的功能，这样一来很多地方就会实现得很累赘，效率也会受损。

2.没有摆脱实验产品的头衔：由于它目前的使用比较低，所以信息反馈和持续改进就做得比较弱，这也是目前功能完善得比较慢的原因之一吧。

3，功能还需要完善：一些主要功能还未实现，如作为Windows平台最基础的COM和COM＋功能没有保存，像MSMQ等消息队列，消息传送的功能也没有实现，对ADO.NET、XML等核心功能效率有待提升，对BCL库代码也有很多需要优化的地方，强大的WPF也没有引入。

4.效率和用户体验还有待提升。

◆ 与微软之间的关系

微软与MONO之间的关系也一直处于不冷不热的状态，没有明确的反对，也没有明确的支持，究其原因笔者认为主要有以下两点：

1，微软带来最大收益的产品仍旧是Windows操作系统和Office等软件，微软在其他领域盈利都没有这两大产品来得直接。而.NET作为微软的强大开发平台，是不希望落在其他平台上运行的，这样就会削弱Windows操作系统和Office等软件的市场占有率，所以让.NET跨平台对微软来说是一件舍本求末的事情，这也是微软不主张.NET运行于其他平台的主要原因，你想微软是一个以技术为主导的公司，任何IT市场都会有它的身影，如果想让.NET跨平台，那岂不是一件很轻而易举的事情吗？

2，由于MONO还没有成熟，在很多方面都表现得像一个实验室产品，在根本上没有对微软构成威胁，况且在外界质疑.NET是否能跨平台的时候，还有一个现身的说法，所以微软也不会明确的反对和支持。

◆ 总结

　　虽然目前来说MONO喜忧参半，但优点始终要大于缺点，毕竟每一个框架或者产品都是慢慢不断改进而完善的，更何况开源必将是未来的一个趋势，所以我们有理由也有信心期待它接下来的发展。

3，谈谈源码研究与TDD

　　大家都有一个共识：如果你想研究某个框架或者工具的源码，那先必须熟练使用它，熟练之后自然就有一种研究它的冲动，但是往往这个框架或工具比较庞大，很不容易下手，一个很不错的方法就是使用TDD。我们都知道TDD的基本思想就是在开发功能代码之前，先编写测试代码。也就是说在明确要开发某个功能后，首先思考如何对这个功能进行测试，并完成测试代码的编写，然后编写相关的代码满足这些测试用例。然后循环进行添加其他功能，直到完全部功能的开发，在此过程中我们可以借助一些工具来协助。比如我们现在要研究Nhibernate，那么我们首先要熟练它的一些功能，然后从一个点出发慢慢编写单元测试，然后逐渐完善代码，最后直至完成框架的搭建，这样会给我们带来莫大的驱动力和成就感。除了微软的BCL（Base Class Library）和企业库以外，大家还可以用TDD来试试还原以下的任一开源代码：

Spring.NET（http://www.springframework.net/）、Castle（http://www.castleproject.org）、log4net（http://logging.apache.org/log4net/）、

NHibernate（http://www.hibernate.org/343.html）、iBATIS.NET（http://ibatis.apache.org）、Caliburn（http://caliburn.codeplex.com/）、

MVVM Light Toolkit（http://mvvmlight.codeplex.com/）、Prism（http://compositewpf.codeplex.com/）、MONO源码（www.mono-project.com）

四. 依赖属性续前缘

　　大家都知道WPF和Silverlight带来了很多新的特性，其中一大亮点是引入了一种新的属性机制——依赖属性。依赖属性基本应用在了WPF的所有需要设置属性的元素。依赖属性根据多个提供对象来决定它的值（可以是动画、父类元素、绑定、样式和模板等），同时这个值也能及时响应变化。所以WPF拥有了依赖属性后，代码写起来就比较得心应手，功能实现上也变得非常容易了。如果没有依赖属性，我们将不得不编写大量的代码。依赖属性在WPF中用得非常广泛，具体在以下几个方面中表现得尤为突出：

◆ UI的强大属性体系

◆ Property value inheritance（值继承）

◆ Metadata（强大的元数据）

◆ 属性变化通知，限制、验证

◆ Resources（资源）

◆ Data binding（数据绑定）

◆ Styles、Template（样式、模板和风格）

◆ 路由事件、附加事件、附加行为乃至命令

◆ Animations、3D（动画和3D）

◆ WPF Designer Integration（WPF设计、开发集成）

　　在上一篇WPF基础到企业应用系列7——深入剖析依赖属性中，我们对依赖属性做了较详细的介绍，那么下面我们就简单回顾一下，其实依赖属性的实现很简单，只要做以下步骤就可以实现：

◆ 第一步： 让所在类型继承自 DependencyObject基类，在WPF中，我们仔细观察框架的类图结构，你会发现几乎所有的 WPF 控件都间接继承自DependencyObject类型。
◆ 第二步：使用 public static 声明一个 DependencyProperty的变量，该变量才是真正的依赖属性 ，看源码就知道这里其实用了简单的单例模式的原理进行了封装(构造函数私有)，只暴露Register方法给外部调用。
◆ 第三步：在静态构造函数中完成依赖属性的元数据注册，并获取对象引用，看代码就知道是把刚才声明的依赖属性放入到一个类似于容器的地方，没有讲实现原理之前，请容许我先这么陈述。
◆ 第四步：在前面的三步中，我们完成了一个依赖属性的注册，那么我们怎样才能对这个依赖属性进行读写呢？答案就是提供一个依赖属性的实例化包装属性，通过这个属性来实现具体的读写操作。

根据前面的四步操作，我们就可以写出下面的代码：

   1: public class SampleDPClass : DependencyObject
<!--CRLF--> 
   2:  {
<!--CRLF--> 
   3:      //声明一个静态只读的DependencyProperty字段
<!--CRLF--> 
   4:      public static readonly DependencyProperty SampleProperty;
<!--CRLF--> 
   5:
<!--CRLF--> 
   6:      static SampleDPClass()
<!--CRLF--> 
   7:      {
<!--CRLF--> 
   8:          //注册我们定义的依赖属性Sample
<!--CRLF--> 
   9:          SampleProperty = DependencyProperty.Register("Sample", typeof(string), typeof(SampleDPClass),
<!--CRLF--> 
  10:              new PropertyMetadata("Knights Warrior!", OnValueChanged));
<!--CRLF--> 
  11:      }
<!--CRLF--> 
  12:
<!--CRLF--> 
  13:      private static void OnValueChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
<!--CRLF--> 
  14:      {
<!--CRLF--> 
  15:          //当值改变时，我们可以在此做一些逻辑处理
<!--CRLF--> 
  16:      }
<!--CRLF--> 
  17:
<!--CRLF--> 
  18:      //属性包装器，通过它来读取和设置我们刚才注册的依赖属性
<!--CRLF--> 
  19:      public string Sample
<!--CRLF--> 
  20:      {
<!--CRLF--> 
  21:          get { return (string)GetValue(SampleProperty); }
<!--CRLF--> 
  22:          set { SetValue(SampleProperty, value); }
<!--CRLF--> 
  23:      }
<!--CRLF--> 
  24:  }
<!--CRLF-->

　　通过上面的例子可以看出，我们一般.NET属性是直接对类的一个私有属性进行封装，所以读取值的时候，也就是直接读取这个字段；而依赖属性则是通过调用继承自DependencyObject的GetValue()和SetValue来进行操作，它实际存储在DependencyProperty的一个IDictionary的键-值配对字典中，所以一条记录中的键(Key)就是该属性的HashCode值，而值(Value)则是我们注册的DependencyProperty。 回顾了一些基础知识，那我们下面就开始今天的依赖属性系统TDD之旅。

五. 引入测试驱动开发

1，引入概念

　　由于本篇的依赖属性体系是基于测试驱动开发完成的，所以我们就先来看一下什么叫测试驱动开发：测试驱动开发的基本思想就是在开发功能代码之前，先编写测试代码。也就是说在明确要开发某个功能后，首先思考如何对这个功能进行测试，并完成测试代码的编写，然后编写相关的代码满足这些测试用例。然后循环进行添加其他功能，直到完全部功能的开发。由于过程很长，在写的时候也省略了不少步骤，所以有些地方衔接不是那么的流畅，对此表示非常的抱歉！

2，注意事项

根据自身做项目使用TDD的一点微薄经验，总结了以下几个注意事项：

◆ 找准切入点：

　　不论是开发一个新的系统还是复原系统，都必须先找准一个或多个切入点，从切入点经历”测试代码－功能代码－测试－重构“来逐渐完善整个系统，往往这个切入点就是功能点，就是这个系统具备哪些功能，然后根据这些功能写出测试用例。

◆ 测试列表：

　　大家都知道一个系统或者一个框架都是很庞大的，如果要引入测试驱动开发，首先我们必须要有一个测试列表，在任何阶段想添加功能需求问题时，把相关功能点加到测试列表中，然后继续开发的工作。然后不断的完成对应的测试用例、功能代码、重构。这样可以避免疏漏的同时也能把控当前的进度。

◆ 测试驱动：

　　这个比较核心。完成某个功能，某个类，首先编写测试代码，考虑其如何使用、如何测试。然后在对其进行设计、编码。这里也强调先编写对功能代码的判断用的断言语句，然后编写相应的辅助语句。

◆ 良好的代码设计及可测性：

功能代码设计、开发时应该具有较强的可测试性。应该尽量保持良好的设计原则和代码规范，如尽量依赖于接口、尽量高内聚、低耦合等等。

◆ 模块或功能隔离：

　　不同代码的测试应该相互隔离。对一块代码的测试只考虑此代码的测试，不要考虑其实现细节，不然就会陷入一团乱麻之中，这个可以通过MOCK来实现，同时在开始的时候也要划分好边界。

◆ 适当引入MOCK：

　　在适当情况下引入MOCK来完成单元测试，这种情况尤其是在边际交互比较多的案例当中，对于交互比较多且复杂的多个类关系可以用MOCK暂时模拟，这是一个不错的解决方案。

◆ 由小到大、由偏到全、统筹兼顾：

　　一个产品或者一个项目是比较大的，所以我们这里就需要遵循由小到大、由偏到全、统筹兼顾的原则，分解功能和代码。把所有的规模大、复杂性高的工作，分解成小的任务来完成，这样既方便团队协作，同时也减轻了复杂度，使整个开发一下子变得简单了许多。

◆ 保持随时重构的习惯：

　　很多开发者在经过测试代码－功能代码－测试通过以后就当完成了任务，其实你会发现随着其他功能的引入或者使用过程中发现了很多重复、冗余的代码、再或者先前的代码结构和设计不太合理，这个时候就需要随时的进行重构和单元测试，在一方面可以避免产生风险，另一方面可以使系统更加完善。

◆ 随时进行回归：

　　在”测试代码－功能代码－测试－重构“的循环中一定要记住多回归，因为这样可以保证当前的代码是不是会影响到前面的功能，其实只需要看看红绿灯就行。

◆ 查看和统计代码覆盖率：

　　通过前面的步骤之后，我们就要看一下实现的功能是否达到我们的预期目标，除了功能完善之外，还要保证代码的覆盖率，因为它是一个系统稳定与否、可维护性与否的一个重大标志。

3，工具介入

　　以后写关于TDD的文章可能比较多，同时也都会用到这个工具，所以我们今天对它也稍带介绍一下，正所谓“工欲善其事，必先利其器”。根据官方文档解释：TestDriven.NET是Visual Studio的一个TDD插件，最近版本是TestDriven.NET-3.0.2749 RTM版。其中一些新特性有：支持MSTest、.NET Reflector 6 Pro、VS 2010、Silverlight 4、NUnit 2.5.3，使用项目所用的.NET框架等。 下载地址：http://www.testdriven.net/

这个工具使用起来比VS自带的单元测试和测试覆盖功能好用，所以从2008年开始基本就用它作为一个必备的工具使用。关于它具体的功能和怎么使用，我们这里不详细介绍，网上也有很多文章，大家可以做一下参考和研究。下图是安装后以插件的形式出现在VS中的效果：

WPF基础到企业应用系列8——依赖属性之“风云再起”_第1张图片

A，基本介绍

　　TestDriven.NET原来叫做NUnitAddIn，它是个Visual Studio插件，集成了如下测试框架：NUnit、MbUnit、 ZaneBug、MSTest、NCover、NCoverExplorer、Reflector、TypeMock、dotTrace和MSBee，它主要面向使用TDD的开发者，主要特性列举如下：

◆ 单键运行方法、类、命名空间、项目和解决方案中的单元测试

◆ 能够快速测试实例方法、静态方法或属性

◆ 可以直接跳到.NET Reflector中的任何方法、类型、项目或引用中，这个功能提供了相当大的方便

◆ 在调试过程中可以查看.NET Reflector中的任何模块或堆栈信息

◆ 支持多种单元测试框架，包括NUnit、MbUnit、xUnit和MSTest

◆ 测试运行在自己的进程中以消除其他问题和边际效应

◆ 可以轻松对任何目标测试进行调试或执行代码覆盖率测试（比微软自带的单元测试和代码覆盖功能要好用多了）

◆ 支持所有主流的.NET语言：C#、VB、C++和F#

B，TestDriven.NET 3.0中的新特性：

◆ TestDriven.Net是基于.NET框架的。再由于VS 2010支持使用多个.NET版本，所以支持各个VS版本和工具就没有问题了

◆ 完全支持在VS 2008和VS 2010中使用MSTest

◆ 完全支持.NET Reflector 6 Pro

◆ 支持NUnit 2.5.3

◆ 支持和兼容VS 2005、VS 2008、VS 2010几个版本

◆ 支持Silverlight 4的测试

C，兼容性

　　TestDriven.NET兼容于如下VS版本：Windows XP、Vista、Windows 7、Windows 2000、Windows 2003和Windows 2008（32和64位）上的Visual Studio 2005、2008和2010。官方已经不再对VS 2003支持。

D，版本

◆ 企业版：每台机器一个许可认证

◆ 专业版：一般的许可形式

◆ 个人版：面向学生、开源开发者和试验用户的免费许可（大家可以下载这个版本，个人感觉很好用）

4，关于本篇

　　本篇文章没有明确的写作意图，只是最近在深入研究MONO源码时有感而发，当然作者本人也只是起到了一个研究者或者剖析者的角色。首先实现最简单且基本的DependencyProperty.Register功能，然后再实现DependencyObject的GetValue和SetValue，接着实现PropertyMetadata的DefaultValue、PropertyChangedCallback、CoerceValueCallback等功能，然后完善DependencyProperty.Register注册时添加ValidateValueCallback、RegisterAttached、RegisterAttachedReadOnly、RegisterReadOnly、OverrideMetadata、GetMetadata和AddOwner等相关功能。既然有了这些功能，自然就需要完善PropertyMetadata的IsSealed、Merge和OnApply等相关底层操作。当然在中间还需要DependencyObject的ClearValue、CoerceValue、GetLocalValueEnumerator、ReadLocalValue以及其他的Helper类，这里就不一一进行说明。对于边际交互比较多且关联比较大的操作，采用了Mock进行暂时模拟，在开发完了以后再进行了替换。在开发过程中，随时进行单元测试和覆盖率的检查，这样可以方便查看哪些功能还有问题以及整体的进度和质量的监控。

六. DependencyProperty测试代码

在写DependencyProperty测试代码之前，我们先看一下它到底有哪些成员和方法，如下图：

WPF基础到企业应用系列8——依赖属性之“风云再起”_第2张图片

　　了解了上面DependencyProperty的基本功能，我们首先创建一个继承自DependencyObject的类ObjectPoker，由于DependencyObject还没有被创建，所以我们这里就先创建它，然后在ObjectPoker类里面实现我们的经典语句DependencyProperty.Register，由于Register有很多重载，为了方便TDD，就从最简单的开始（三个参数，不牵涉到元数据类），然后再创建一个ObjectPoker的子类，这是方便后面测试DependencyProperty的相关功能。

   1: class ObjectPoker : DependencyObject
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     //注册依赖属性property1
<!--CRLF--> 
   4:     public static readonly DependencyProperty TestProp1 = DependencyProperty.Register("property1", typeof(string), typeof(ObjectPoker));
<!--CRLF--> 
   5: }
<!--CRLF--> 
   6:
<!--CRLF--> 
   7: class SubclassPoker : ObjectPoker
<!--CRLF--> 
   8: {
<!--CRLF--> 
   9: }
<!--CRLF-->

　　经过上面的测试用例通过以后，自然DependencyProperty.Register的基本功能也就完善了，然后我们来测试一下Register两个相同的依赖属性有什么反应，由于我们为了实现Register时没有考虑那么多，所以测试是先会失败，然后在引入键值对的形式来存储DependencyProperty，然后每个DependencyProperty都用Name.GetHashCode() ^ PropertyType.GetHashCode() ^ OwnerType.GetHashCode()来区别唯一，所以相同下面的测试用例也将完成。

   1: [Test]
<!--CRLF--> 
   2: [ExpectedException(typeof(ArgumentException))]
<!--CRLF--> 
   3: public void TestMultipleRegisters()
<!--CRLF--> 
   4: {
<!--CRLF--> 
   5:     //测试注册相同名的依赖属性
<!--CRLF--> 
   6:     DependencyProperty.Register("p1", typeof(string), typeof(ObjectPoker));
<!--CRLF--> 
   7:     DependencyProperty.Register("p1", typeof(string), typeof(ObjectPoker));
<!--CRLF--> 
   8: }
<!--CRLF-->

　　我们说到依赖属性系统，其实依赖属性要依附于DependencyObject才能成为真正的依赖属性系统。所以我们来测试一下AddOwner，每一个Owner都有自己的元数据，这个时候我们需要完善OverrideMetadata方法，然而OverrideMetadata方法需要用到PropertyMetadata类作为参数，同时需要调用PropertyMetadata类的DoMerge方法，我们可以创建该类，然后结合Mock完成该操作。

   1: [Test]
<!--CRLF--> 
   2: [ExpectedException(typeof(ArgumentException))]
<!--CRLF--> 
   3: public void TestMultipleAddOwner()
<!--CRLF--> 
   4: {
<!--CRLF--> 
   5:     //测试AddOwner，添加相同类型的Owner
<!--CRLF--> 
   6:     ObjectPoker.TestProp1.AddOwner(typeof(SubclassPoker), new PropertyMetadata());
<!--CRLF--> 
   7:     ObjectPoker.TestProp1.AddOwner(typeof(SubclassPoker), new PropertyMetadata());
<!--CRLF--> 
   8: }
<!--CRLF-->

通过上面的测试用例以后，其实PropertyMetadata的原型已经具备了，然后我们要做的就是测试DependencyProperty的默认元数据和默认元数据的默认值。

   1: [Test]
<!--CRLF--> 
   2: public void TestDefaultMetadata()
<!--CRLF--> 
   3: {
<!--CRLF--> 
   4:     //测试默认元数据
<!--CRLF--> 
   5:     DependencyProperty p;
<!--CRLF--> 
   6:     p = DependencyProperty.Register("TestDefaultMetadata1", typeof(string), typeof(ObjectPoker));
<!--CRLF--> 
   7:     Assert.IsNotNull(p.DefaultMetadata);
<!--CRLF--> 
   8:
<!--CRLF--> 
   9:     //测试元数据的默认值
<!--CRLF--> 
  10:     p = DependencyProperty.Register("TestDefaultMetadata2", typeof(string), typeof(ObjectPoker), new PropertyMetadata("hi"));
<!--CRLF--> 
  11:     Assert.IsNotNull(p.DefaultMetadata);
<!--CRLF--> 
  12:     Assert.AreEqual("hi", p.DefaultMetadata.DefaultValue);
<!--CRLF--> 
  13: }
<!--CRLF-->

　　我们都知道一个DependencyProperty可以拥有多个Owner，每个Owner之间的区别就是用PropertyMetadata，那么这里就给该DependencyProperty添加一个Owner，然后通过该Owner来获取元数据。

   1: [Test]
<!--CRLF--> 
   2: public void TestAddOwnerNullMetadata()
<!--CRLF--> 
   3: {
<!--CRLF--> 
   4:     //首先注册一个依赖属性，然后再AddOwner，最后根据新的Owner获取元数据
<!--CRLF--> 
   5:     DependencyProperty p = DependencyProperty.Register("TestAddOwnerNullMetadata", typeof(string), typeof(ObjectPoker));
<!--CRLF--> 
   6:     p.AddOwner(typeof(SubclassPoker), null);
<!--CRLF--> 
   7:
<!--CRLF--> 
   8:     PropertyMetadata pm = p.GetMetadata(typeof(SubclassPoker));
<!--CRLF--> 
   9:     Assert.IsNotNull(pm);
<!--CRLF--> 
  10: }
<!--CRLF-->

　　通过上面的测试用例，我们牵涉到了OverrideMetadata方法，当然上面没有进行实现，这个时候我们可以来实现OverrideMetadata这个方法，首先注册一个ObjectPoker类型的依赖属性，然后通过SubclassPoker来OverrideMetadata。

   1: //首先注册一个依赖属性，然后再OverrideMetadata
<!--CRLF--> 
   2: [Test]
<!--CRLF--> 
   3: [ExpectedException(typeof(ArgumentNullException))]
<!--CRLF--> 
   4: public void TestOverrideMetadataNullMetadata()
<!--CRLF--> 
   5: {
<!--CRLF--> 
   6:     //有Type但PropertyMetadata为null时，OverrideMetadata操作
<!--CRLF--> 
   7:     DependencyProperty p = DependencyProperty.Register("TestOverrideMetadataNullMetadata", typeof(string), typeof(ObjectPoker));
<!--CRLF--> 
   8:     p.OverrideMetadata(typeof(SubclassPoker), null);
<!--CRLF--> 
   9: }
<!--CRLF-->

　　上面实现了OverrideMetadata的函数，但是只是简单实现，这里我们可以传入一个null类型的Type作为测试，当然测试不会通过，然后就修改代码直到测试通过吧！

   1: [Test]
<!--CRLF--> 
   2: [ExpectedException(typeof(ArgumentNullException))]
<!--CRLF--> 
   3: public void TestOverrideMetadataNullType()
<!--CRLF--> 
   4: {
<!--CRLF--> 
   5:     //当Type为null，OverrideMetadata操作
<!--CRLF--> 
   6:     DependencyProperty p = DependencyProperty.Register("TestOverrideMetadataNullType", typeof(string), typeof(ObjectPoker));
<!--CRLF--> 
   7:     p.OverrideMetadata(null, new PropertyMetadata());
<!--CRLF--> 
   8: }
<!--CRLF-->

　　如果仔细分析DependencyProperty的源码，你会发现有一个DependencyPropertyKey类，这个类到底是干嘛的呢？其实这个类的主要作用就是构造函数传入该DependencyProperty，然后通过Type来OverrideMetadata，这里只是提供了一个简单的封装，如果没有这个类，其他功能照样正常。

   1: [Test]
<!--CRLF--> 
   2: [ExpectedException(typeof(InvalidOperationException))]
<!--CRLF--> 
   3: public void TestReadonlyOverrideMetadata()
<!--CRLF--> 
   4: {
<!--CRLF--> 
   5:     //通过DependencyPropertyKey的方式OverrideMetadata
<!--CRLF--> 
   6:     DependencyPropertyKey ro_key = DependencyProperty.RegisterReadOnly("readonly-prop1",
<!--CRLF--> 
   7:                                         typeof(double),
<!--CRLF--> 
   8:                                         typeof(ObjectPoker),
<!--CRLF--> 
   9:                                         new PropertyMetadata(double.NaN));
<!--CRLF--> 
  10:     ro_key.DependencyProperty.OverrideMetadata(typeof(SubclassPoker), new PropertyMetadataPoker());
<!--CRLF--> 
  11: }
<!--CRLF-->

最后我们来测试一样通过DependencyPropertyKey类来注册一个ReadOnly的依赖属性，然后进行OverrideMetadata，基本和上一个测试用例类似。

   1: [Test]
<!--CRLF--> 
   2: public void TestReadonlyOverrideMetadataFromKey()
<!--CRLF--> 
   3: {
<!--CRLF--> 
   4:     //通过DependencyPropertyKey的方式OverrideMetadata
<!--CRLF--> 
   5:     DependencyPropertyKey ro_key = DependencyProperty.RegisterReadOnly("readonly-prop2",
<!--CRLF--> 
   6:                                         typeof(double),
<!--CRLF--> 
   7:                                         typeof(ObjectPoker),
<!--CRLF--> 
   8:                                         new PropertyMetadata(double.NaN));
<!--CRLF--> 
   9:     ro_key.OverrideMetadata(typeof(SubclassPoker), new PropertyMetadataPoker());
<!--CRLF--> 
  10: }
<!--CRLF-->

　　通过上面的测试用例，DependencyProperty类已经基本完成，除了该类，其他诸如DependencyObject、PropertyMetadata、DependencyPropertyKey也已经初步完成，所以我们这里先以DependencyProperty作为切入点，那么下面就来看一下刚才创建的DependencyProperty类。

七. DependencyProperty实现代码

具体代码如下，我们就不做过多阐述，不过有几点需要注意：

1，一个依赖属性可能有多个所有者，所以根据每个所有者都有自己的元数据。

2，依赖属性私有构造函数，作为初始化操作，每个依赖属性在注册的时候都会调用并初始化数据

3，为了区别不同的依赖属性，Name、PropertyType、OwnerType的哈希值取异。

4，注册依赖属性有以下几个种类：Register、RegisterAttached、RegisterAttachedReadOnly和RegisterReadOnly，所以要区别对待。

5，由于一个依赖属性可能有多个Owner，根据每个Owner都有自己的元数据，所以要有根据Owner的AddOwner、GetMetadata和OverrideMetadata的操作。

   1:
<!--CRLF--> 
   2: using System.Collections.Generic;
<!--CRLF--> 
   3: namespace System.Windows
<!--CRLF--> 
   4: {
<!--CRLF--> 
   5:     public sealed class DependencyProperty
<!--CRLF--> 
   6:     {
<!--CRLF--> 
   7:         //一个依赖属性可能有多个所有者，所以根据每个所有者都有自己的元数据
<!--CRLF--> 
   8:         private Dictionary<Type,PropertyMetadata> metadataByType = new Dictionary<Type,PropertyMetadata>();
<!--CRLF--> 
   9:
<!--CRLF--> 
  10:         //声明一个UnsetValue
<!--CRLF--> 
  11:         public static readonly object UnsetValue = new object ();
<!--CRLF--> 
  12:
<!--CRLF--> 
  13:         //依赖属性私有构造函数，作为初始化操作，每个依赖属性在注册的时候都会调用并初始化数据
<!--CRLF--> 
  14:         private DependencyProperty (bool isAttached, string name, Type propertyType, Type ownerType,
<!--CRLF--> 
  15:                         PropertyMetadata defaultMetadata,
<!--CRLF--> 
  16:                         ValidateValueCallback validateValueCallback)
<!--CRLF--> 
  17:         {
<!--CRLF--> 
  18:             IsAttached = isAttached;
<!--CRLF--> 
  19:             DefaultMetadata = (defaultMetadata == null ? new PropertyMetadata() : defaultMetadata);
<!--CRLF--> 
  20:             Name = name;
<!--CRLF--> 
  21:             OwnerType = ownerType;
<!--CRLF--> 
  22:             PropertyType = propertyType;
<!--CRLF--> 
  23:             ValidateValueCallback = validateValueCallback;
<!--CRLF--> 
  24:         }
<!--CRLF--> 
  25:
<!--CRLF--> 
  26:         internal bool IsAttached { get; set; }
<!--CRLF--> 
  27:         public bool ReadOnly { get; private set; }
<!--CRLF--> 
  28:         public PropertyMetadata DefaultMetadata { get; private set; }
<!--CRLF--> 
  29:         public string Name { get; private set; }
<!--CRLF--> 
  30:         public Type OwnerType { get; private set; }
<!--CRLF--> 
  31:         public Type PropertyType { get; private set; }
<!--CRLF--> 
  32:         public ValidateValueCallback ValidateValueCallback { get; private set; }
<!--CRLF--> 
  33:
<!--CRLF--> 
  34:         //获取依赖属性的编号，暂未实现,在上一篇“WPF基础到企业应用系列7——深入剖析依赖属性”有实现，原理是在初始化的时候++
<!--CRLF--> 
  35:         public int GlobalIndex {
<!--CRLF--> 
  36:             get { throw new NotImplementedException (); }
<!--CRLF--> 
  37:         }
<!--CRLF--> 
  38:
<!--CRLF--> 
  39:         //传入ownerType增加Owner
<!--CRLF--> 
  40:         public DependencyProperty AddOwner(Type ownerType)
<!--CRLF--> 
  41:         {
<!--CRLF--> 
  42:             return AddOwner (ownerType, null);
<!--CRLF--> 
  43:         }
<!--CRLF--> 
  44:
<!--CRLF--> 
  45:         //增加所有者，根据ownerType和typeMetadata
<!--CRLF--> 
  46:         public DependencyProperty AddOwner(Type ownerType, PropertyMetadata typeMetadata)
<!--CRLF--> 
  47:         {
<!--CRLF--> 
  48:             if (typeMetadata == null) typeMetadata = new PropertyMetadata ();
<!--CRLF--> 
  49:             OverrideMetadata (ownerType, typeMetadata);
<!--CRLF--> 
  50:
<!--CRLF--> 
  51:             // MS seems to always return the same DependencyProperty
<!--CRLF--> 
  52:             return this;
<!--CRLF--> 
  53:         }
<!--CRLF--> 
  54:
<!--CRLF--> 
  55:         //获取元数据，依据forType
<!--CRLF--> 
  56:         public PropertyMetadata GetMetadata(Type forType)
<!--CRLF--> 
  57:         {
<!--CRLF--> 
  58:             if (metadataByType.ContainsKey (forType))
<!--CRLF--> 
  59:                 return metadataByType[forType];
<!--CRLF--> 
  60:             return null;
<!--CRLF--> 
  61:         }
<!--CRLF--> 
  62:
<!--CRLF--> 
  63:         //获取元数据，依据该依赖属性
<!--CRLF--> 
  64:         public PropertyMetadata GetMetadata(DependencyObject d)
<!--CRLF--> 
  65:         {
<!--CRLF--> 
  66:             if (metadataByType.ContainsKey (d.GetType()))
<!--CRLF--> 
  67:                 return metadataByType[d.GetType()];
<!--CRLF--> 
  68:             return null;
<!--CRLF--> 
  69:         }
<!--CRLF--> 
  70:
<!--CRLF--> 
  71:         //获取元数据，依据dependencyObjectType
<!--CRLF--> 
  72:         public PropertyMetadata GetMetadata(DependencyObjectType dependencyObjectType)
<!--CRLF--> 
  73:         {
<!--CRLF--> 
  74:             if (metadataByType.ContainsKey (dependencyObjectType.SystemType))
<!--CRLF--> 
  75:                 return metadataByType[dependencyObjectType.SystemType];
<!--CRLF--> 
  76:             return null;
<!--CRLF--> 
  77:         }
<!--CRLF--> 
  78:
<!--CRLF--> 
  79:         //验证类型是否有效
<!--CRLF--> 
  80:         public bool IsValidType(object value)
<!--CRLF--> 
  81:         {
<!--CRLF--> 
  82:             return PropertyType.IsInstanceOfType (value);
<!--CRLF--> 
  83:         }
<!--CRLF--> 
  84:
<!--CRLF--> 
  85:         //验证值是否有效
<!--CRLF--> 
  86:         public bool IsValidValue(object value)
<!--CRLF--> 
  87:         {
<!--CRLF--> 
  88:             if (!IsValidType (value))
<!--CRLF--> 
  89:                 return false;
<!--CRLF--> 
  90:             if (ValidateValueCallback == null)
<!--CRLF--> 
  91:                 return true;
<!--CRLF--> 
  92:             return ValidateValueCallback (value);
<!--CRLF--> 
  93:         }
<!--CRLF--> 
  94:
<!--CRLF--> 
  95:         //重写元数据，使用PropertyMetadata类的DoMerge方法来操作
<!--CRLF--> 
  96:         public void OverrideMetadata(Type forType, PropertyMetadata typeMetadata)
<!--CRLF--> 
  97:         {
<!--CRLF--> 
  98:             if (forType == null)
<!--CRLF--> 
  99:                 throw new ArgumentNullException ("forType");
<!--CRLF--> 
 100:             if (typeMetadata == null)
<!--CRLF--> 
 101:                 throw new ArgumentNullException ("typeMetadata");
<!--CRLF--> 
 102:
<!--CRLF--> 
 103:             if (ReadOnly)
<!--CRLF--> 
 104:                 throw new InvalidOperationException (String.Format ("Cannot override metadata on readonly property '{0}' without using a DependencyPropertyKey", Name));
<!--CRLF--> 
 105:
<!--CRLF--> 
 106:             typeMetadata.DoMerge (DefaultMetadata, this, forType);
<!--CRLF--> 
 107:             metadataByType.Add (forType, typeMetadata);
<!--CRLF--> 
 108:         }
<!--CRLF--> 
 109:
<!--CRLF--> 
 110:         //重写元数据，使用PropertyMetadata类的DoMerge方法来操作
<!--CRLF--> 
 111:         public void OverrideMetadata (Type forType, PropertyMetadata typeMetadata, DependencyPropertyKey key)
<!--CRLF--> 
 112:         {
<!--CRLF--> 
 113:             if (forType == null)
<!--CRLF--> 
 114:                 throw new ArgumentNullException ("forType");
<!--CRLF--> 
 115:             if (typeMetadata == null)
<!--CRLF--> 
 116:                 throw new ArgumentNullException ("typeMetadata");
<!--CRLF--> 
 117:
<!--CRLF--> 
 118:             typeMetadata.DoMerge (DefaultMetadata, this, forType);
<!--CRLF--> 
 119:             metadataByType.Add (forType, typeMetadata);
<!--CRLF--> 
 120:         }
<!--CRLF--> 
 121:
<!--CRLF--> 
 122:         public override string ToString ()
<!--CRLF--> 
 123:         {
<!--CRLF--> 
 124:             return Name;
<!--CRLF--> 
 125:         }
<!--CRLF--> 
 126:
<!--CRLF--> 
 127:         //得到哈希值，区别不同的依赖属性，Name、PropertyType、OwnerType的哈希值取异
<!--CRLF--> 
 128:         public override int GetHashCode ()
<!--CRLF--> 
 129:         {
<!--CRLF--> 
 130:             return Name.GetHashCode() ^ PropertyType.GetHashCode() ^ OwnerType.GetHashCode();
<!--CRLF--> 
 131:         }
<!--CRLF--> 
 132:
<!--CRLF--> 
 133:         //注册依赖属性（参数：依赖属性名、依赖属性的Type、拥有者的Type）
<!--CRLF--> 
 134:         public static DependencyProperty Register(string name, Type propertyType, Type ownerType)
<!--CRLF--> 
 135:         {
<!--CRLF--> 
 136:             return Register(name, propertyType, ownerType, null, null);
<!--CRLF--> 
 137:         }
<!--CRLF--> 
 138:
<!--CRLF--> 
 139:         //注册依赖属性（参数：依赖属性名、依赖属性的Type、拥有者的Type、元数据）
<!--CRLF--> 
 140:         public static DependencyProperty Register(string name, Type propertyType, Type ownerType,
<!--CRLF--> 
 141:                               PropertyMetadata typeMetadata)
<!--CRLF--> 
 142:         {
<!--CRLF--> 
 143:             return Register(name, propertyType, ownerType, typeMetadata, null);
<!--CRLF--> 
 144:         }
<!--CRLF--> 
 145:
<!--CRLF--> 
 146:         //注册依赖属性（参数：依赖属性名、依赖属性的Type、拥有者的Type、元数据、验证回调委托）
<!--CRLF--> 
 147:         public static DependencyProperty Register(string name, Type propertyType, Type ownerType,
<!--CRLF--> 
 148:                               PropertyMetadata typeMetadata,
<!--CRLF--> 
 149:                               ValidateValueCallback validateValueCallback)
<!--CRLF--> 
 150:         {
<!--CRLF--> 
 151:             if (typeMetadata == null)
<!--CRLF--> 
 152:                 typeMetadata = new PropertyMetadata();
<!--CRLF--> 
 153:
<!--CRLF--> 
 154:             DependencyProperty dp = new DependencyProperty(false, name, propertyType, ownerType,
<!--CRLF--> 
 155:                                        typeMetadata, validateValueCallback);
<!--CRLF--> 
 156:             DependencyObject.register(ownerType, dp);
<!--CRLF--> 
 157:
<!--CRLF--> 
 158:             dp.OverrideMetadata (ownerType, typeMetadata);
<!--CRLF--> 
 159:
<!--CRLF--> 
 160:             return dp;
<!--CRLF--> 
 161:         }
<!--CRLF--> 
 162:
<!--CRLF--> 
 163:         //注册附加依赖属性（参数：依赖属性名、依赖属性的Type、拥有者的Type）
<!--CRLF--> 
 164:         public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType)
<!--CRLF--> 
 165:         {
<!--CRLF--> 
 166:             return RegisterAttached(name, propertyType, ownerType, null, null);
<!--CRLF--> 
 167:         }
<!--CRLF--> 
 168:
<!--CRLF--> 
 169:         //注册附加依赖属性（参数：依赖属性名、依赖属性的Type、拥有者的Type、元数据）
<!--CRLF--> 
 170:         public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType,
<!--CRLF--> 
 171:                                   PropertyMetadata defaultMetadata)
<!--CRLF--> 
 172:         {
<!--CRLF--> 
 173:             return RegisterAttached(name, propertyType, ownerType, defaultMetadata, null);
<!--CRLF--> 
 174:         }
<!--CRLF--> 
 175:
<!--CRLF--> 
 176:         //注册附加依赖属性（参数：依赖属性名、依赖属性的Type、拥有者的Type、元数据、验证回调委托）
<!--CRLF--> 
 177:         public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType,
<!--CRLF--> 
 178:                                   PropertyMetadata defaultMetadata,
<!--CRLF--> 
 179:                                   ValidateValueCallback validateValueCallback)
<!--CRLF--> 
 180:         {
<!--CRLF--> 
 181:             DependencyProperty dp = new DependencyProperty(true, name, propertyType, ownerType,
<!--CRLF--> 
 182:                                        defaultMetadata, validateValueCallback);
<!--CRLF--> 
 183:             DependencyObject.register(ownerType, dp);
<!--CRLF--> 
 184:             return dp;
<!--CRLF--> 
 185:         }
<!--CRLF--> 
 186:
<!--CRLF--> 
 187:         //注册只读依赖属性，暂未实现
<!--CRLF--> 
 188:         public static DependencyPropertyKey RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType,
<!--CRLF--> 
 189:                                          PropertyMetadata defaultMetadata)
<!--CRLF--> 
 190:         {
<!--CRLF--> 
 191:             throw new NotImplementedException("RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata)");
<!--CRLF--> 
 192:         }
<!--CRLF--> 
 193:
<!--CRLF--> 
 194:         //注册只读依赖属性，暂未实现
<!--CRLF--> 
 195:         public static DependencyPropertyKey RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType,
<!--CRLF--> 
 196:                                          PropertyMetadata defaultMetadata,
<!--CRLF--> 
 197:                                          ValidateValueCallback validateValueCallback)
<!--CRLF--> 
 198:         {
<!--CRLF--> 
 199:             throw new NotImplementedException("RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)");
<!--CRLF--> 
 200:         }
<!--CRLF--> 
 201:
<!--CRLF--> 
 202:         //注册只读依赖属性（参数：依赖属性名、依赖属性的Type、拥有者的Type、元数据）
<!--CRLF--> 
 203:         public static DependencyPropertyKey RegisterReadOnly(string name, Type propertyType, Type ownerType,
<!--CRLF--> 
 204:                                      PropertyMetadata typeMetadata)
<!--CRLF--> 
 205:         {
<!--CRLF--> 
 206:             return RegisterReadOnly (name, propertyType, ownerType, typeMetadata, null);
<!--CRLF--> 
 207:         }
<!--CRLF--> 
 208:
<!--CRLF--> 
 209:         //注册只读依赖属性（参数：依赖属性名、依赖属性的Type、拥有者的Type、元数据、验证回调委托）
<!--CRLF--> 
 210:         public static DependencyPropertyKey RegisterReadOnly(string name, Type propertyType, Type ownerType,
<!--CRLF--> 
 211:                                      PropertyMetadata typeMetadata,
<!--CRLF--> 
 212:                                      ValidateValueCallback validateValueCallback)
<!--CRLF--> 
 213:         {
<!--CRLF--> 
 214:             DependencyProperty prop = Register (name, propertyType, ownerType, typeMetadata, validateValueCallback);
<!--CRLF--> 
 215:             prop.ReadOnly = true;
<!--CRLF--> 
 216:             return new DependencyPropertyKey (prop);
<!--CRLF--> 
 217:         }
<!--CRLF--> 
 218:
<!--CRLF--> 
 219:     }
<!--CRLF--> 
 220: }
<!--CRLF-->

通过前面的步骤，DependencyProperty已经完成，那么下面我们再来看一下DependencyObject类。

八. DependencyObject测试代码

在写DependencyObject测试代码之前，我们先看一下它到底有哪些成员和方法，如下图：

WPF基础到企业应用系列8——依赖属性之“风云再起”_第3张图片

　　通过上面的这幅图，我们知道它的主要功能包括：各种依赖属性的GetValue、SetValue操作（核心功能）和ClearValue、CoerceValue、GetLocalValueEnumerator、ReadLocalValue等操作。为了测试这些功能，我们首先创建几个类，第一个类X，内部首先注册一个附加依赖属性，我们都知道，不管是附加依赖属性还是依赖属性，都需要使用到GetValue和SetValue操作，只是一个封装成了属性，而另一个封装成了静态方法而已。第二个类直接继承自我们前面在实现DependencyProperty时创建的DependencyObject原型类。

   1: class X {
<!--CRLF--> 
   2:     //注册一个附加依赖属性A
<!--CRLF--> 
   3:     public static readonly DependencyProperty AProperty = DependencyProperty.RegisterAttached("A", typeof(int), typeof(X));
<!--CRLF--> 
   4:     //获取附加属性A的值
<!--CRLF--> 
   5:     public static void SetA(DependencyObject obj, int value)
<!--CRLF--> 
   6:     {
<!--CRLF--> 
   7:         obj.SetValue(AProperty, value);
<!--CRLF--> 
   8:     }
<!--CRLF--> 
   9:     //设置附加属性A的值
<!--CRLF--> 
  10:     public static int GetA(DependencyObject obj)
<!--CRLF--> 
  11:     {
<!--CRLF--> 
  12:         return (int)obj.GetValue(AProperty);
<!--CRLF--> 
  13:     }
<!--CRLF--> 
  14:     //注册一个附加依赖属性B
<!--CRLF--> 
  15:     public static readonly DependencyProperty BProperty = DependencyProperty.RegisterAttached("B", typeof(string), typeof(X));
<!--CRLF--> 
  16:     //设置附加属性B的值
<!--CRLF--> 
  17:     public static void SetB(DependencyObject obj, string value)
<!--CRLF--> 
  18:     {
<!--CRLF--> 
  19:         obj.SetValue(BProperty, value);
<!--CRLF--> 
  20:     }
<!--CRLF--> 
  21:     //获取附加属性B的值
<!--CRLF--> 
  22:     public static string GetB(DependencyObject obj)
<!--CRLF--> 
  23:     {
<!--CRLF--> 
  24:         return (string)obj.GetValue(BProperty);
<!--CRLF--> 
  25:     }
<!--CRLF--> 
  26:
<!--CRLF--> 
  27: }
<!--CRLF--> 
  28:
<!--CRLF--> 
  29: class Y : DependencyObject {
<!--CRLF--> 
  30: }
<!--CRLF-->

第三个类则是为了直接测试注册一个依赖属性，这个类首先继承自DependencyObject原型类。

   1: class Z : DependencyObject
<!--CRLF--> 
   2:   {
<!--CRLF--> 
   3:       public static readonly DependencyProperty SimpleDPProperty =
<!--CRLF--> 
   4:          DependencyProperty.Register("SimpleDP", typeof(double), typeof(Z),
<!--CRLF--> 
   5:              new PropertyMetadata((double)0.0,
<!--CRLF--> 
   6:                  new PropertyChangedCallback(OnValueChanged),
<!--CRLF--> 
   7:                  new CoerceValueCallback(CoerceValue)),
<!--CRLF--> 
   8:                  new ValidateValueCallback(IsValidValue));
<!--CRLF--> 
   9:
<!--CRLF--> 
  10:       public double SimpleDP
<!--CRLF--> 
  11:       {
<!--CRLF--> 
  12:           get { return (double)GetValue(SimpleDPProperty); }
<!--CRLF--> 
  13:           set { SetValue(SimpleDPProperty, value); }
<!--CRLF--> 
  14:       }
<!--CRLF--> 
  15:
<!--CRLF--> 
  16:       private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
<!--CRLF--> 
  17:       {
<!--CRLF--> 
  18:           Console.WriteLine("当值改变时，我们可以做的一些操作，具体可以在这里定义： {0}", e.NewValue);
<!--CRLF--> 
  19:       }
<!--CRLF--> 
  20:
<!--CRLF--> 
  21:       private static object CoerceValue(DependencyObject d, object value)
<!--CRLF--> 
  22:       {
<!--CRLF--> 
  23:           Console.WriteLine("对值进行限定，强制值： {0}", value);
<!--CRLF--> 
  24:           return value;
<!--CRLF--> 
  25:       }
<!--CRLF--> 
  26:
<!--CRLF--> 
  27:       private static bool IsValidValue(object value)
<!--CRLF--> 
  28:       {
<!--CRLF--> 
  29:           Console.WriteLine("验证值是否通过，如果返回True表示验证通过，否则会以异常的形式暴露： {0}", value);
<!--CRLF--> 
  30:           return true;
<!--CRLF--> 
  31:       }
<!--CRLF--> 
  32:
<!--CRLF--> 
  33:   }
<!--CRLF-->

首先我们先写测试GetValue和SetValue操作的测试代码，然后不能通过，最后完善DependencyObject类的GetValue和SetValue方法直到测试用例通过。

   1: [Test]
<!--CRLF--> 
   2: [Category ("NotWorking")]
<!--CRLF--> 
   3: public void TestAttachedProperty()
<!--CRLF--> 
   4: {
<!--CRLF--> 
   5:     Y y1 = new Y();
<!--CRLF--> 
   6:     X.SetA(y1, 2);
<!--CRLF--> 
   7:     Assert.AreEqual(2, X.GetA(y1));
<!--CRLF--> 
   8: }
<!--CRLF-->

由于这里是y1和y2两个对象，所以他们的GetValue和SetValue也是设置和取得各自的值。

   1: [Test]
<!--CRLF--> 
   2:     [Category ("NotWorking")]
<!--CRLF--> 
   3:     public void Test2AttachedProperties()
<!--CRLF--> 
   4:     {
<!--CRLF--> 
   5:         Y y1 = new Y();
<!--CRLF--> 
   6:         Y y2 = new Y();
<!--CRLF--> 
   7:         X.SetA(y1, 2);
<!--CRLF--> 
   8:         X.SetA(y2, 3);
<!--CRLF--> 
   9:         Assert.AreEqual(2, X.GetA(y1));
<!--CRLF--> 
  10:         Assert.AreEqual(3, X.GetA(y2));
<!--CRLF--> 
  11:     }
<!--CRLF-->

　　通过前面的图，大家可以看到DependencyObject提供了一个取得本地值枚举器的GetLocalValueEnumerator方法，它实现一个IEnumerator来方便访问LocalValue，这里我们要实现它，所以先写测试代码。

   1: [Test]
<!--CRLF--> 
   2:     [Category ("NotWorking")]
<!--CRLF--> 
   3:     public void TestEnumerationOfAttachedProperties()
<!--CRLF--> 
   4:     {
<!--CRLF--> 
   5:         int count = 0;
<!--CRLF--> 
   6:         Y y = new Y();
<!--CRLF--> 
   7:         X.SetA(y, 2);
<!--CRLF--> 
   8:         X.SetB(y, "Hi");
<!--CRLF--> 
   9:
<!--CRLF--> 
  10:         //根据DependencyObject得到所有本地值
<!--CRLF--> 
  11:         LocalValueEnumerator e = y.GetLocalValueEnumerator();
<!--CRLF--> 
  12:         while (e.MoveNext()) {
<!--CRLF--> 
  13:             count++;
<!--CRLF--> 
  14:             if (e.Current.Property == X.AProperty)
<!--CRLF--> 
  15:                 Assert.AreEqual(e.Current.Value, 2);
<!--CRLF--> 
  16:             else if (e.Current.Property == X.BProperty)
<!--CRLF--> 
  17:                 Assert.AreEqual(e.Current.Value, "Hi");
<!--CRLF--> 
  18:             else
<!--CRLF--> 
  19:                 Assert.Fail("Wrong sort of property" + e.Current.Property);
<!--CRLF--> 
  20:         }
<!--CRLF--> 
  21:         //count为2
<!--CRLF--> 
  22:         Assert.AreEqual(2, count);
<!--CRLF--> 
  23:     }
<!--CRLF-->

还有几个功能，既然Mono也没做研究，我们也就不费那个力气了，接下来我们就看看刚才实现的DependencyObject代码吧！

九. DependencyObject实现代码

通过前面的测试用例，DependencyObject类的基本功能已经完成，不过我们要注意几个要点：
1，依赖属性其实终究要DependencyObject和DependencyProperty成对才能算得上真正的DependencyProperty

2，不管是Register、RegisterAttached、RegisterAttachedReadOnly还是RegisterReadOnly操作，我们都要通过DependencyObject来操作DependencyProperty的值，也就是通过DependencyObject这个外部接口来操作，DependencyProperty只负责注册和内部处理，不负责外部接口。

3，在DependencyObject中提供了几个操作LocalValue的接口的接口，其中包括ReadLocalValue、GetLocalValueEnumerator、CoerceValue和ClearValue等。

4，在注册注册依赖属性时，实质是关联DependencyObject的propertyDeclarations，它是一个Dictionary<Type,Dictionary<string,DependencyProperty>>类型，但是在register代码中并没有完全关联起来，我也比较纳闷，所以这点还希望和大家一起探讨，微软的BCL并没有这么实现。

   1: using System.Collections.Generic;
<!--CRLF--> 
   2: //using System.Windows.Threading;
<!--CRLF--> 
   3:
<!--CRLF--> 
   4: namespace System.Windows
<!--CRLF--> 
   5: {
<!--CRLF--> 
   6:     public class DependencyObject
<!--CRLF--> 
   7:     {
<!--CRLF--> 
   8:         //依赖属性其实终究要DependencyObject和DependencyProperty成对才能算得上真正的DependencyProperty
<!--CRLF--> 
   9:         private static Dictionary<Type,Dictionary<string,DependencyProperty>> propertyDeclarations = new Dictionary<Type,Dictionary<string,DependencyProperty>>();
<!--CRLF--> 
  10:         //该依赖属性的键值对，键为DependencyProperty，值为object
<!--CRLF--> 
  11:         private Dictionary<DependencyProperty,object> properties = new Dictionary<DependencyProperty,object>();
<!--CRLF--> 
  12:
<!--CRLF--> 
  13:         //是否已密封，没有实现DependencyObject层次的IsSealed判断
<!--CRLF--> 
  14:         public bool IsSealed {
<!--CRLF--> 
  15:             get { return false; }
<!--CRLF--> 
  16:         }
<!--CRLF--> 
  17:
<!--CRLF--> 
  18:         //获取该DependencyObject的DependencyObjectType
<!--CRLF--> 
  19:         public DependencyObjectType DependencyObjectType {
<!--CRLF--> 
  20:             get { return DependencyObjectType.FromSystemType (GetType()); }
<!--CRLF--> 
  21:         }
<!--CRLF--> 
  22:
<!--CRLF--> 
  23:         //根据该依赖属性名，清除它的值
<!--CRLF--> 
  24:         public void ClearValue(DependencyProperty dp)
<!--CRLF--> 
  25:         {
<!--CRLF--> 
  26:             if (IsSealed)
<!--CRLF--> 
  27:                 throw new InvalidOperationException ("Cannot manipulate property values on a sealed DependencyObject");
<!--CRLF--> 
  28:
<!--CRLF--> 
  29:             properties[dp] = null;
<!--CRLF--> 
  30:         }
<!--CRLF--> 
  31:
<!--CRLF--> 
  32:         //根据该依赖属性DependencyPropertyKey，清除它的值
<!--CRLF--> 
  33:         public void ClearValue(DependencyPropertyKey key)
<!--CRLF--> 
  34:         {
<!--CRLF--> 
  35:             ClearValue (key.DependencyProperty);
<!--CRLF--> 
  36:         }
<!--CRLF--> 
  37:
<!--CRLF--> 
  38:         //根据该依赖属性名，强制值
<!--CRLF--> 
  39:         public void CoerceValue (DependencyProperty dp)
<!--CRLF--> 
  40:         {
<!--CRLF--> 
  41:             PropertyMetadata pm = dp.GetMetadata (this);
<!--CRLF--> 
  42:             if (pm.CoerceValueCallback != null)
<!--CRLF--> 
  43:                 pm.CoerceValueCallback (this, GetValue (dp));
<!--CRLF--> 
  44:         }
<!--CRLF--> 
  45:
<!--CRLF--> 
  46:         public sealed override bool Equals (object obj)
<!--CRLF--> 
  47:         {
<!--CRLF--> 
  48:             throw new NotImplementedException("Equals");
<!--CRLF--> 
  49:         }
<!--CRLF--> 
  50:
<!--CRLF--> 
  51:         public sealed override int GetHashCode ()
<!--CRLF--> 
  52:         {
<!--CRLF--> 
  53:             throw new NotImplementedException("GetHashCode");
<!--CRLF--> 
  54:         }
<!--CRLF--> 
  55:
<!--CRLF--> 
  56:         //得到本地值的枚举器
<!--CRLF--> 
  57:         public LocalValueEnumerator GetLocalValueEnumerator()
<!--CRLF--> 
  58:         {
<!--CRLF--> 
  59:             return new LocalValueEnumerator(properties);
<!--CRLF--> 
  60:         }
<!--CRLF--> 
  61:
<!--CRLF--> 
  62:         //根据依赖属性名获取值
<!--CRLF--> 
  63:         public object GetValue(DependencyProperty dp)
<!--CRLF--> 
  64:         {
<!--CRLF--> 
  65:             object val = properties[dp];
<!--CRLF--> 
  66:             return val == null ? dp.DefaultMetadata.DefaultValue : val;
<!--CRLF--> 
  67:         }
<!--CRLF--> 
  68:
<!--CRLF--> 
  69:
<!--CRLF--> 
  70:         public void InvalidateProperty(DependencyProperty dp)
<!--CRLF--> 
  71:         {
<!--CRLF--> 
  72:             throw new NotImplementedException("InvalidateProperty(DependencyProperty dp)");
<!--CRLF--> 
  73:         }
<!--CRLF--> 
  74:
<!--CRLF--> 
  75:         //当属性值改变时，触发回调
<!--CRLF--> 
  76:         protected virtual void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
<!--CRLF--> 
  77:         {
<!--CRLF--> 
  78:             PropertyMetadata pm = e.Property.GetMetadata (this);
<!--CRLF--> 
  79:             if (pm.PropertyChangedCallback != null)
<!--CRLF--> 
  80:                 pm.PropertyChangedCallback (this, e);
<!--CRLF--> 
  81:         }
<!--CRLF--> 
  82:
<!--CRLF--> 
  83:         //提供一个外界查看LocalValue的接口
<!--CRLF--> 
  84:         public object ReadLocalValue(DependencyProperty dp)
<!--CRLF--> 
  85:         {
<!--CRLF--> 
  86:             object val = properties[dp];
<!--CRLF--> 
  87:             return val == null ? DependencyProperty.UnsetValue : val;
<!--CRLF--> 
  88:         }
<!--CRLF--> 
  89:
<!--CRLF--> 
  90:         //根据依赖属性名设置其值
<!--CRLF--> 
  91:         public void SetValue(DependencyProperty dp, object value)
<!--CRLF--> 
  92:         {
<!--CRLF--> 
  93:             if (IsSealed)
<!--CRLF--> 
  94:                 throw new InvalidOperationException ("Cannot manipulate property values on a sealed DependencyObject");
<!--CRLF--> 
  95:
<!--CRLF--> 
  96:             if (!dp.IsValidType (value))
<!--CRLF--> 
  97:                 throw new ArgumentException ("value not of the correct type for this DependencyProperty");
<!--CRLF--> 
  98:
<!--CRLF--> 
  99:             ValidateValueCallback validate = dp.ValidateValueCallback;
<!--CRLF--> 
 100:             if (validate != null && !validate(value))
<!--CRLF--> 
 101:                 throw new Exception("Value does not validate");
<!--CRLF--> 
 102:             else
<!--CRLF--> 
 103:                 properties[dp] = value;
<!--CRLF--> 
 104:         }
<!--CRLF--> 
 105:
<!--CRLF--> 
 106:         //根据依赖属性DependencyPropertyKey设置其值
<!--CRLF--> 
 107:         public void SetValue(DependencyPropertyKey key, object value)
<!--CRLF--> 
 108:         {
<!--CRLF--> 
 109:             SetValue (key.DependencyProperty, value);
<!--CRLF--> 
 110:         }
<!--CRLF--> 
 111:
<!--CRLF--> 
 112:         protected virtual bool ShouldSerializeProperty (DependencyProperty dp)
<!--CRLF--> 
 113:         {
<!--CRLF--> 
 114:             throw new NotImplementedException ();
<!--CRLF--> 
 115:         }
<!--CRLF--> 
 116:
<!--CRLF--> 
 117:         //这里的注册实质是关联propertyDeclarations
<!--CRLF--> 
 118:         internal static void register(Type t, DependencyProperty dp)
<!--CRLF--> 
 119:         {
<!--CRLF--> 
 120:             if (!propertyDeclarations.ContainsKey (t))
<!--CRLF--> 
 121:                 propertyDeclarations[t] = new Dictionary<string,DependencyProperty>();
<!--CRLF--> 
 122:             Dictionary<string,DependencyProperty> typeDeclarations = propertyDeclarations[t];
<!--CRLF--> 
 123:             if (!typeDeclarations.ContainsKey(dp.Name))
<!--CRLF--> 
 124:             {
<!--CRLF--> 
 125:                 typeDeclarations[dp.Name] = dp;
<!--CRLF--> 
 126:                 //这里仍然有一些问题，期待各位共同探讨解决
<!--CRLF--> 
 127:             }
<!--CRLF--> 
 128:             else
<!--CRLF--> 
 129:                 throw new ArgumentException("A property named " + dp.Name + " already exists on " + t.Name);
<!--CRLF--> 
 130:         }
<!--CRLF--> 
 131:     }
<!--CRLF--> 
 132: }
<!--CRLF-->

　　通过前面对DependencyObject和DependencyProperty的研究之后，我们来看看最重要的一个角色，这也是微软最喜欢用的概念——元数据，如果大家研究过微软BCL的源码，应该都知道，它是贯穿于整个CLR当中的。

十. PropertyMetadata测试代码

前面我们看到一个依赖属性的注册最全的形式是下面这样子的：

public static DependencyProperty Register(string name, 
                                          Type propertyType,
                                          Type ownerType, 
                                          PropertyMetadata typeMetadata,
                                          ValidateValueCallback validateValueCallback);

　　第一个参数是该依赖属性的名字，第二个参数是依赖属性的类型，第三个参数是该依赖属性的所有者的类型，第五个参数就是一个验证值的回调委托，那么最使我们感兴趣的还是这个可爱的 PropertyMetadata ，也就是我们接下来要讲的元数据。 提到WPF属性元数据，大家可能第一想到的是刚才的PropertyMetadata，那么这个类到底是怎样的呢？我们应该怎样使用它呢？首先我们看它的构造函数（我们选参数最多的来讲）：

public PropertyMetadata(object defaultValue,
                        PropertyChangedCallback propertyChangedCallback, 
                        CoerceValueCallback coerceValueCallback);

　　其中的第一个参数是默认值，最后两个分别是PropertyChanged（变化通知）以及Coerce（强制）的两个委托变量，我们在实例化的时候，只需要把这两个委托变量关联到具体的方法上即可。

　　事实上，除了PropertyMetadata以外，常见的还有FrameworkPropertyMetadata，UIPropertyMetadata。他们的继承关系是F->U->P。其中以FrameworkPropertyMetadata参数最多，亦最为复杂。

FrameworkPropertyMetadata的构造函数提供了很多重载，我们挑选最为复杂的重载来看它到底有哪些参数以及提供了哪些功能：

public FrameworkPropertyMetadata(object defaultValue,
                                 FrameworkPropertyMetadataOptions flags,
                                 PropertyChangedCallback propertyChangedCallback, 
                                 CoerceValueCallback coerceValueCallback,
                                 bool isAnimationProhibited,
                                 UpdateSourceTrigger defaultUpdateSourceTrigger);

　　其中第一个参数是默认值，最后两个参数分别是是否允许动画，以及绑定时更新的策略（在Binding当中相信大家并不陌生），这个不详细解释了。重点看一下里第三、四两个参数，两个 CallBack的委托。结合前面Register的时候提到的ValidateValueCallback共组成三大”金刚“，这三个Callback分别代表Validate（验证），PropertyChanged（变化通知）以及Coerce（强制）。当然，作为 Metadata，FrameworkPropertyMetadata只是储存了该依赖属性的策略信息，WPF属性系统会根据这些信息来提供功能并在适当的时机回调传入的delegate，所以最重要的还是我们定义的这些方法，通过他们传入委托才能起到真正的作用。

具体PropertyMetadata包含哪些成员呢？我们先看微软的PropertyMetadata类

WPF基础到企业应用系列8——依赖属性之“风云再起”_第4张图片

　　在写其他测试用例之前，我们先来创建两个类，第一个类TestDepObj，内部注册了四个依赖属性，前三个没有元数据操作，也就是没有显示声明并构造元数据类，第四个添加了一个元数据类，这个元数据类包含了默认值、值改变回调委托、强制值回调委托。第二个类TestSubclass继承自TestDepObj。

   1: class TestDepObj : DependencyObject
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     public static readonly DependencyProperty TestProp1 = DependencyProperty.Register("property1", typeof(string), typeof(TestDepObj));
<!--CRLF--> 
   4:     public static readonly DependencyProperty TestProp2 = DependencyProperty.Register("property2", typeof(string), typeof(TestDepObj));
<!--CRLF--> 
   5:     public static readonly DependencyProperty TestProp3 = DependencyProperty.Register("property3", typeof(string), typeof(TestDepObj));
<!--CRLF--> 
   6:
<!--CRLF--> 
   7:     public static readonly DependencyProperty TestProp4 = DependencyProperty.Register("property4", typeof(string), typeof(TestDepObj), new PropertyMetadata("default", changed, coerce));
<!--CRLF--> 
   8:
<!--CRLF--> 
   9:     static void changed(DependencyObject d, DependencyPropertyChangedEventArgs e) { }
<!--CRLF--> 
  10:     static object coerce(DependencyObject d, object baseValue) { return baseValue; }
<!--CRLF--> 
  11: }
<!--CRLF--> 
  12:
<!--CRLF--> 
  13: class TestSubclass : TestDepObj
<!--CRLF--> 
  14: {
<!--CRLF--> 
  15: }
<!--CRLF-->

　　大家看到我们在创建PropertyMetadata的时候对某些功能并没有实现，这里我们就通过子类来具体实现，MONO的这种做法想沿袭微软PropertyMetadata、FrameworkPropertyMetadata和UIPropertyMetadata的做法，但是个人觉得它实现得并不是太好，很多地方感觉很别扭。

   1: //首先我们自定义一个元数据类，继承自我们刚创建的PropertyMetadata类
<!--CRLF--> 
   2:   public class PropertyMetadataPoker : PropertyMetadata
<!--CRLF--> 
   3:   {
<!--CRLF--> 
   4:
<!--CRLF--> 
   5:       public bool BaseIsSealed
<!--CRLF--> 
   6:       {
<!--CRLF--> 
   7:           get { return base.IsSealed; }
<!--CRLF--> 
   8:       }
<!--CRLF--> 
   9:
<!--CRLF--> 
  10:       public void CallApply()
<!--CRLF--> 
  11:       {
<!--CRLF--> 
  12:           OnApply(TestDepObj.TestProp1, typeof(TestDepObj));
<!--CRLF--> 
  13:       }
<!--CRLF--> 
  14:
<!--CRLF--> 
  15:       public void CallMerge(PropertyMetadata baseMetadata, DependencyProperty dp)
<!--CRLF--> 
  16:       {
<!--CRLF--> 
  17:           Merge(baseMetadata, dp);
<!--CRLF--> 
  18:       }
<!--CRLF--> 
  19:
<!--CRLF--> 
  20:       protected override void Merge(PropertyMetadata baseMetadata, DependencyProperty dp)
<!--CRLF--> 
  21:       {
<!--CRLF--> 
  22:           Console.WriteLine(Environment.StackTrace);
<!--CRLF--> 
  23:           base.Merge(baseMetadata, dp);
<!--CRLF--> 
  24:       }
<!--CRLF--> 
  25:
<!--CRLF--> 
  26:       protected override void OnApply(DependencyProperty dp, Type targetType)
<!--CRLF--> 
  27:       {
<!--CRLF--> 
  28:           //
<!--CRLF--> 
  29:           base.OnApply(dp, targetType);
<!--CRLF--> 
  30:           Console.WriteLine("IsSealed in OnApply? {0}", IsSealed);
<!--CRLF--> 
  31:           Console.WriteLine(Environment.StackTrace);
<!--CRLF--> 
  32:       }
<!--CRLF--> 
  33:   }
<!--CRLF-->

　　下面的测试代码主要看一下元数据的默认值，实例化一个元数据类，然后调用它的DefaultValue、PropertyChangedCallback、CoerceValueCallback，测试他们是否为Null。

   1: [Test]
<!--CRLF--> 
   2:     public void DefaultValues()
<!--CRLF--> 
   3:     {
<!--CRLF--> 
   4:         //首先看看元数据的默认值
<!--CRLF--> 
   5:         PropertyMetadataPoker m = new PropertyMetadataPoker();
<!--CRLF--> 
   6:         Assert.AreEqual(null, m.DefaultValue);
<!--CRLF--> 
   7:         Assert.AreEqual(null, m.PropertyChangedCallback);
<!--CRLF--> 
   8:         Assert.AreEqual(null, m.CoerceValueCallback);
<!--CRLF--> 
   9:     }
<!--CRLF-->

　　我们在WPF和Silverlight中都有过这样的体会：到底什么时候这个依赖属性不能再修改了，其实这个操作得归功于OnApply什么时候触发，我们也可以调用IsSealed来查看，那么这里我们就先写测试代码。第一段代码直接显示调用CallApply方法进行密封；第二段代码则是通过OverrideMetadata操作后内部调用的CallApply；第三段代码是通过AddOwner操作中调用的CallApply；最后一段代码通过调用DependencyProperty.Register时传入元数据，在其内部调用CallApply。

   1: [Test]
<!--CRLF--> 
   2:   public void IsSealed()
<!--CRLF--> 
   3:   {
<!--CRLF--> 
   4:       //测试元数据是否密封，这个很重要，因为封闭之后就不能修改了，除非用OverrideMetadata或者AddOwner
<!--CRLF--> 
   5:       PropertyMetadataPoker m;
<!--CRLF--> 
   6:
<!--CRLF--> 
   7:       Console.WriteLine(1);
<!--CRLF--> 
   8:       // 直接调用 OnApply 查看元数据是否密封
<!--CRLF--> 
   9:       m = new PropertyMetadataPoker();
<!--CRLF--> 
  10:       Assert.IsFalse(m.BaseIsSealed);
<!--CRLF--> 
  11:       m.CallApply();
<!--CRLF--> 
  12:       Assert.IsFalse(m.BaseIsSealed);
<!--CRLF--> 
  13:
<!--CRLF--> 
  14:       Console.WriteLine(2);
<!--CRLF--> 
  15:       // 直接 OverrideMetadata
<!--CRLF--> 
  16:       m = new PropertyMetadataPoker();
<!--CRLF--> 
  17:       TestDepObj.TestProp1.OverrideMetadata(typeof(TestSubclass), m);
<!--CRLF--> 
  18:       Assert.IsTrue(m.BaseIsSealed);
<!--CRLF--> 
  19:
<!--CRLF--> 
  20:       Console.WriteLine(3);
<!--CRLF--> 
  21:       // 调用 DependencyProperty.AddOwner, 通过这种方式 OverrideMetadata
<!--CRLF--> 
  22:       m = new PropertyMetadataPoker();
<!--CRLF--> 
  23:       TestDepObj.TestProp2.AddOwner(typeof(TestSubclass), m);
<!--CRLF--> 
  24:       Assert.IsTrue(m.BaseIsSealed);
<!--CRLF--> 
  25:
<!--CRLF--> 
  26:       Console.WriteLine(4);
<!--CRLF--> 
  27:       // 最后, 调用DependencyProperty.Register时传入元数据
<!--CRLF--> 
  28:       m = new PropertyMetadataPoker();
<!--CRLF--> 
  29:       DependencyProperty.Register("xxx", typeof(string), typeof(TestDepObj), m);
<!--CRLF--> 
  30:       Assert.IsTrue(m.BaseIsSealed);
<!--CRLF--> 
  31:   }
<!--CRLF-->

下面这段测试代码是验证AddOwner后的DependencyProperty是否和原来的DependencyProperty是同一个DependencyProperty。

   1: [Test]
<!--CRLF--> 
   2:    public void TestAddOwnerResult()
<!--CRLF--> 
   3:    {
<!--CRLF--> 
   4:        //测试AddOwner后的DependencyProperty是否和原来的DependencyProperty是同一个DependencyProperty
<!--CRLF--> 
   5:        PropertyMetadataPoker m = new PropertyMetadataPoker();
<!--CRLF--> 
   6:        DependencyProperty p = TestDepObj.TestProp3.AddOwner(typeof(TestSubclass), m);
<!--CRLF--> 
   7:
<!--CRLF--> 
   8:        //结果是同一个DependencyProperty
<!--CRLF--> 
   9:        Assert.AreSame(p, TestDepObj.TestProp3);
<!--CRLF--> 
  10:    }
<!--CRLF-->

　　下面这个测试用例是首先实例化元数据并作为注册依赖属性时的参数传入，大家都知道此时如果想修改元数据，可以通过AddOwner或者OverrideMetadata，如果直接赋值，会抛出错误，因为元数据已经密封。

   1: [Test]
<!--CRLF--> 
   2:     [ExpectedException(typeof(InvalidOperationException))]
<!--CRLF--> 
   3:     public void ModifyAfterSealed1()
<!--CRLF--> 
   4:     {
<!--CRLF--> 
   5:         //首先实例化元数据并注册依赖属性时作为参数传入
<!--CRLF--> 
   6:         PropertyMetadataPoker m = new PropertyMetadataPoker();
<!--CRLF--> 
   7:         DependencyProperty.Register("p1", typeof(string), typeof(TestDepObj), m);
<!--CRLF--> 
   8:         Assert.IsTrue(m.BaseIsSealed);
<!--CRLF--> 
   9:
<!--CRLF--> 
  10:         //由于元数据已密封，所以抛出如下错误信息：Cannot change metadata once it has been applied to a property
<!--CRLF--> 
  11:         m.CoerceValueCallback = null;
<!--CRLF--> 
  12:     }
<!--CRLF-->

这个和上面的那个测试用例基本一样，只不过把CoerceValueCallback换成了PropertyChangedCallback

   1: [Test]
<!--CRLF--> 
   2:    [ExpectedException(typeof(InvalidOperationException))]
<!--CRLF--> 
   3:    public void ModifyAfterSealed2()
<!--CRLF--> 
   4:    {
<!--CRLF--> 
   5:        //首先实例化元数据并注册依赖属性时作为参数传入
<!--CRLF--> 
   6:        PropertyMetadataPoker m = new PropertyMetadataPoker();
<!--CRLF--> 
   7:        DependencyProperty.Register("p2", typeof(string), typeof(TestDepObj), m);
<!--CRLF--> 
   8:        Assert.IsTrue(m.BaseIsSealed);
<!--CRLF--> 
   9:
<!--CRLF--> 
  10:        //由于元数据已密封，所以抛出如下错误信息：Cannot change metadata once it has been applied to a property
<!--CRLF--> 
  11:        m.PropertyChangedCallback = null;
<!--CRLF--> 
  12:    }
<!--CRLF-->

下面这个测试用例也和上面的两个测试用例类似，它是修改元数据的DefaultValue

   1: [Test]
<!--CRLF--> 
   2:       [ExpectedException(typeof(InvalidOperationException))]
<!--CRLF--> 
   3:       public void ModifyAfterSealed3()
<!--CRLF--> 
   4:       {
<!--CRLF--> 
   5:           //首先实例化元数据并注册依赖属性时作为参数传入
<!--CRLF--> 
   6:           PropertyMetadataPoker m = new PropertyMetadataPoker();
<!--CRLF--> 
   7:           DependencyProperty.Register("p3", typeof(string), typeof(TestDepObj), m);
<!--CRLF--> 
   8:           Assert.IsTrue(m.BaseIsSealed);
<!--CRLF--> 
   9:
<!--CRLF--> 
  10:           //由于元数据已密封，所以抛出如下错误信息：Cannot change metadata once it has been applied to a property
<!--CRLF--> 
  11:           m.DefaultValue = "hi";
<!--CRLF--> 
  12:       }
<!--CRLF-->

　　通过前面的测试用例，大家可能都会发现有一个Merge这个方法，它在什么时候调用呢？其实它在OverrideMetadata和AddOwner操作中都会调用，在

DependencyProperty中的Register也会显示调用一次。我们需要注意的是：在元数据密封了以后就会抛出错误。

   1: [Test]
<!--CRLF--> 
   2:     public void TestMerge()
<!--CRLF--> 
   3:     {
<!--CRLF--> 
   4:         //需要注意的是：在元数据密封了以后就会抛出错误
<!--CRLF--> 
   5:         PropertyMetadataPoker m = new PropertyMetadataPoker();
<!--CRLF--> 
   6:         m.CallMerge(TestDepObj.TestProp4.GetMetadata(typeof(TestDepObj)), TestDepObj.TestProp4);
<!--CRLF--> 
   7:         Assert.AreEqual("default", m.DefaultValue);
<!--CRLF--> 
   8:         Assert.IsNotNull(m.CoerceValueCallback);
<!--CRLF--> 
   9:         Assert.IsNotNull(m.PropertyChangedCallback);
<!--CRLF--> 
  10:
<!--CRLF--> 
  11:         m = new PropertyMetadataPoker();
<!--CRLF--> 
  12:         m.DefaultValue = "non-default";
<!--CRLF--> 
  13:         m.CallMerge(TestDepObj.TestProp4.GetMetadata(typeof(TestDepObj)), TestDepObj.TestProp4);
<!--CRLF--> 
  14:         Assert.AreEqual("non-default", m.DefaultValue);
<!--CRLF--> 
  15:         Assert.IsNotNull(m.CoerceValueCallback);
<!--CRLF--> 
  16:         Assert.IsNotNull(m.PropertyChangedCallback);
<!--CRLF--> 
  17:
<!--CRLF--> 
  18:         //我们知道元数据包括DefaultValue、 coerce 和 property changed等
<!--CRLF--> 
  19:         //这里我们就不一一测试了，其他测试结果都是一样的
<!--CRLF--> 
  20:     }
<!--CRLF-->

下面的测试用例主要是默认值是不能被设置成Unset的

   1: [Test]
<!--CRLF--> 
   2:    [ExpectedException(typeof(ArgumentException))]
<!--CRLF--> 
   3:    public void TestSetDefaultToUnsetValue()
<!--CRLF--> 
   4:    {
<!--CRLF--> 
   5:        //默认值是不能被设置成Unset的
<!--CRLF--> 
   6:        PropertyMetadata m = new PropertyMetadata();
<!--CRLF--> 
   7:        m.DefaultValue = DependencyProperty.UnsetValue;
<!--CRLF--> 
   8:    }
<!--CRLF--> 
   9:
<!--CRLF--> 
  10:    [Test]
<!--CRLF--> 
  11:    [ExpectedException(typeof(ArgumentException))]
<!--CRLF--> 
  12:    public void TestInitDefaultToUnsetValue()
<!--CRLF--> 
  13:    {
<!--CRLF--> 
  14:        //默认值是不能被设置成Unset的
<!--CRLF--> 
  15:        new PropertyMetadata(DependencyProperty.UnsetValue);
<!--CRLF--> 
  16:    }
<!--CRLF-->

通过前面的多个测试用例，其实已经包含了PropertyMetadata的基本功能，那我们接下来就看一下PropertyMetadata的内部设计和实现。

十一. PropertyMetadata实现代码

MONO的PropertyMetadata类要比微软的PropertyMetadata类简单很多，不过我们也需要注意一下几点：

1，元数据类包含哪些成员以及有几个构造函数重载？因为这些直接关系到外部的调用。

2，大家要注意ValidateValueCallback不是PropertyMetadata的成员，所以在PropertyMetadata的构造函数中不要把它作为参数传入。

3，注意OnApply函数，因为调用它之后就不能修改元数据的成员，只有通过OverrideMetadata和AddOwner间接实现，如果大家想知道到底这个元数据有没有被密封，可以调用IsSealed属性来查看，这个功能我们也会经常用到。

4，元数据类中提供了Merge的功能，用来方便合并父类和子类的元数据。

   1: namespace System.Windows
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     //依赖属性三大回调委托：PropertyChangedCallback、CoerceValueCallback和ValidateValueCallback
<!--CRLF--> 
   4:     public delegate void PropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e);
<!--CRLF--> 
   5:     public delegate object CoerceValueCallback(DependencyObject d, object baseValue);
<!--CRLF--> 
   6:     public delegate bool ValidateValueCallback(object value);
<!--CRLF--> 
   7:
<!--CRLF--> 
   8:     public class PropertyMetadata
<!--CRLF--> 
   9:     {
<!--CRLF--> 
  10:         private object defaultValue;
<!--CRLF--> 
  11:         private bool isSealed;
<!--CRLF--> 
  12:         private PropertyChangedCallback propertyChangedCallback;
<!--CRLF--> 
  13:         private CoerceValueCallback coerceValueCallback;
<!--CRLF--> 
  14:
<!--CRLF--> 
  15:         //返回该元数据是否已密封
<!--CRLF--> 
  16:         protected bool IsSealed
<!--CRLF--> 
  17:         {
<!--CRLF--> 
  18:             get { return isSealed; }
<!--CRLF--> 
  19:         }
<!--CRLF--> 
  20:
<!--CRLF--> 
  21:         //获取和设置元数据默认值
<!--CRLF--> 
  22:         public object DefaultValue
<!--CRLF--> 
  23:         {
<!--CRLF--> 
  24:             get { return defaultValue; }
<!--CRLF--> 
  25:             set
<!--CRLF--> 
  26:             {
<!--CRLF--> 
  27:                 if (IsSealed)
<!--CRLF--> 
  28:                     throw new InvalidOperationException("Cannot change metadata once it has been applied to a property");
<!--CRLF--> 
  29:                 if (value == DependencyProperty.UnsetValue)
<!--CRLF--> 
  30:                     throw new ArgumentException("Cannot set property metadata's default value to 'Unset'");
<!--CRLF--> 
  31:
<!--CRLF--> 
  32:                 defaultValue = value;
<!--CRLF--> 
  33:             }
<!--CRLF--> 
  34:         }
<!--CRLF--> 
  35:
<!--CRLF--> 
  36:         //ChangedCallback委托赋值，注意检查元数据是否已经密封
<!--CRLF--> 
  37:         public PropertyChangedCallback PropertyChangedCallback
<!--CRLF--> 
  38:         {
<!--CRLF--> 
  39:             get { return propertyChangedCallback; }
<!--CRLF--> 
  40:             set
<!--CRLF--> 
  41:             {
<!--CRLF--> 
  42:                 if (IsSealed)
<!--CRLF--> 
  43:                     throw new InvalidOperationException("Cannot change metadata once it has been applied to a property");
<!--CRLF--> 
  44:                 propertyChangedCallback = value;
<!--CRLF--> 
  45:             }
<!--CRLF--> 
  46:         }
<!--CRLF--> 
  47:
<!--CRLF--> 
  48:         //CoerceValueCallback委托赋值，注意检查元数据是否已经密封
<!--CRLF--> 
  49:         public CoerceValueCallback CoerceValueCallback
<!--CRLF--> 
  50:         {
<!--CRLF--> 
  51:             get { return coerceValueCallback; }
<!--CRLF--> 
  52:             set
<!--CRLF--> 
  53:             {
<!--CRLF--> 
  54:                 if (IsSealed)
<!--CRLF--> 
  55:                     throw new InvalidOperationException("Cannot change metadata once it has been applied to a property");
<!--CRLF--> 
  56:                 coerceValueCallback = value;
<!--CRLF--> 
  57:             }
<!--CRLF--> 
  58:         }
<!--CRLF--> 
  59:
<!--CRLF--> 
  60:         #region PropertyMetadata构造函数，根据不同参数做初始化操作
<!--CRLF--> 
  61:         public PropertyMetadata()
<!--CRLF--> 
  62:             : this(null, null, null)
<!--CRLF--> 
  63:         {
<!--CRLF--> 
  64:         }
<!--CRLF--> 
  65:
<!--CRLF--> 
  66:         public PropertyMetadata(object defaultValue)
<!--CRLF--> 
  67:             : this(defaultValue, null, null)
<!--CRLF--> 
  68:         {
<!--CRLF--> 
  69:         }
<!--CRLF--> 
  70:
<!--CRLF--> 
  71:         public PropertyMetadata(PropertyChangedCallback propertyChangedCallback)
<!--CRLF--> 
  72:             : this(null, propertyChangedCallback, null)
<!--CRLF--> 
  73:         {
<!--CRLF--> 
  74:         }
<!--CRLF--> 
  75:
<!--CRLF--> 
  76:         public PropertyMetadata(object defaultValue, PropertyChangedCallback propertyChangedCallback)
<!--CRLF--> 
  77:             : this(defaultValue, propertyChangedCallback, null)
<!--CRLF--> 
  78:         {
<!--CRLF--> 
  79:         }
<!--CRLF--> 
  80:
<!--CRLF--> 
  81:         public PropertyMetadata(object defaultValue, PropertyChangedCallback propertyChangedCallback, CoerceValueCallback coerceValueCallback)
<!--CRLF--> 
  82:         {
<!--CRLF--> 
  83:             if (defaultValue == DependencyProperty.UnsetValue)
<!--CRLF--> 
  84:                 throw new ArgumentException("Cannot initialize property metadata's default value to 'Unset'");
<!--CRLF--> 
  85:
<!--CRLF--> 
  86:             this.defaultValue = defaultValue;
<!--CRLF--> 
  87:             this.propertyChangedCallback = propertyChangedCallback;
<!--CRLF--> 
  88:             this.coerceValueCallback = coerceValueCallback;
<!--CRLF--> 
  89:         }
<!--CRLF--> 
  90:         #endregion
<!--CRLF--> 
  91:
<!--CRLF--> 
  92:         //合并元数据
<!--CRLF--> 
  93:         protected virtual void Merge(PropertyMetadata baseMetadata, DependencyProperty dp)
<!--CRLF--> 
  94:         {
<!--CRLF--> 
  95:             if (defaultValue == null)
<!--CRLF--> 
  96:                 defaultValue = baseMetadata.defaultValue;
<!--CRLF--> 
  97:             if (propertyChangedCallback == null)
<!--CRLF--> 
  98:                 propertyChangedCallback = baseMetadata.propertyChangedCallback;
<!--CRLF--> 
  99:             if (coerceValueCallback == null)
<!--CRLF--> 
 100:                 coerceValueCallback = baseMetadata.coerceValueCallback;
<!--CRLF--> 
 101:         }
<!--CRLF--> 
 102:
<!--CRLF--> 
 103:         protected virtual void OnApply(DependencyProperty dp, Type targetType)
<!--CRLF--> 
 104:         {
<!--CRLF--> 
 105:             //留给子类来实现吧！
<!--CRLF--> 
 106:         }
<!--CRLF--> 
 107:
<!--CRLF--> 
 108:         //合并元数据并密封
<!--CRLF--> 
 109:         internal void DoMerge(PropertyMetadata baseMetadata, DependencyProperty dp, Type targetType)
<!--CRLF--> 
 110:         {
<!--CRLF--> 
 111:             Merge(baseMetadata, dp);
<!--CRLF--> 
 112:             OnApply(dp, targetType);
<!--CRLF--> 
 113:             isSealed = true;
<!--CRLF--> 
 114:         }
<!--CRLF--> 
 115:     }
<!--CRLF--> 
 116: }
<!--CRLF-->

在上面几个类就是依赖属性系统的核心类，下面将看到几个Helper类。

十二. 其他协助类测试代码

这里就简单写一下对DependencyObjectTypeTest的测试代码：

   1: using System;
<!--CRLF--> 
   2: using System.Windows;
<!--CRLF--> 
   3: using NUnit.Framework;
<!--CRLF--> 
   4:
<!--CRLF--> 
   5: namespace TDDDependencyTest.System.Windows
<!--CRLF--> 
   6: {
<!--CRLF--> 
   7:     [TestFixture]
<!--CRLF--> 
   8:     public class DependencyObjectTypeTest
<!--CRLF--> 
   9:     {
<!--CRLF--> 
  10:
<!--CRLF--> 
  11:         [Test]
<!--CRLF--> 
  12:         public void Accessors()
<!--CRLF--> 
  13:         {
<!--CRLF--> 
  14:             DependencyObjectType t = DependencyObjectType.FromSystemType(typeof(TestDepObj));
<!--CRLF--> 
  15:             Assert.AreEqual("TestDepObj", t.Name);
<!--CRLF--> 
  16:             Assert.AreEqual(typeof(TestDepObj), t.SystemType);
<!--CRLF--> 
  17:             Assert.AreEqual(typeof(DependencyObject), t.BaseType.SystemType);
<!--CRLF--> 
  18:         }
<!--CRLF--> 
  19:
<!--CRLF--> 
  20:         [Test]
<!--CRLF--> 
  21:         public void IsInstanceOfType()
<!--CRLF--> 
  22:         {
<!--CRLF--> 
  23:             DependencyObjectType t = DependencyObjectType.FromSystemType(typeof(TestDepObj));
<!--CRLF--> 
  24:             DependencyObjectType t2 = DependencyObjectType.FromSystemType(typeof(TestSubclass));
<!--CRLF--> 
  25:             Assert.IsTrue(t.IsInstanceOfType(new TestSubclass()));
<!--CRLF--> 
  26:             Assert.IsTrue(t2.IsSubclassOf(t));
<!--CRLF--> 
  27:             Assert.IsFalse(t.IsSubclassOf(t2));
<!--CRLF--> 
  28:         }
<!--CRLF--> 
  29:
<!--CRLF--> 
  30:         [Test]
<!--CRLF--> 
  31:         public void TestCache()
<!--CRLF--> 
  32:         {
<!--CRLF--> 
  33:             DependencyObjectType t = DependencyObjectType.FromSystemType(typeof(TestDepObj));
<!--CRLF--> 
  34:             DependencyObjectType t2 = DependencyObjectType.FromSystemType(typeof(TestDepObj));
<!--CRLF--> 
  35:             Assert.AreSame(t, t2);
<!--CRLF--> 
  36:         }
<!--CRLF--> 
  37:     }
<!--CRLF--> 
  38: }
<!--CRLF-->

由于它的功能比较简单，所以我们就不做过多介绍，大家想了解更多，可以参看代码。

十三. 其他协助类的实现代码

LocalValueEnumerator：手动实现一个IEnumerator来方便访问LocalValue

   1: using System;
<!--CRLF--> 
   2: using System.Collections.Generic;
<!--CRLF--> 
   3: using System.Linq;
<!--CRLF--> 
   4: using System.Text;
<!--CRLF--> 
   5: using System.Collections;
<!--CRLF--> 
   6:
<!--CRLF--> 
   7: namespace System.Windows
<!--CRLF--> 
   8: {
<!--CRLF--> 
   9:     //手动实现一个IEnumerator来方便访问LocalValue
<!--CRLF--> 
  10:     public struct LocalValueEnumerator : IEnumerator
<!--CRLF--> 
  11:     {
<!--CRLF--> 
  12:         private IDictionaryEnumerator propertyEnumerator;
<!--CRLF--> 
  13:         private Dictionary<DependencyProperty, object> properties;
<!--CRLF--> 
  14:
<!--CRLF--> 
  15:         private int count;
<!--CRLF--> 
  16:
<!--CRLF--> 
  17:         internal LocalValueEnumerator(Dictionary<DependencyProperty, object> properties)
<!--CRLF--> 
  18:         {
<!--CRLF--> 
  19:             this.count = properties.Count;
<!--CRLF--> 
  20:             this.properties = properties;
<!--CRLF--> 
  21:             this.propertyEnumerator = properties.GetEnumerator();
<!--CRLF--> 
  22:         }
<!--CRLF--> 
  23:
<!--CRLF--> 
  24:         public int Count
<!--CRLF--> 
  25:         {
<!--CRLF--> 
  26:             get { return count; }
<!--CRLF--> 
  27:         }
<!--CRLF--> 
  28:
<!--CRLF--> 
  29:         //获取当前LocalValue
<!--CRLF--> 
  30:         public LocalValueEntry Current
<!--CRLF--> 
  31:         {
<!--CRLF--> 
  32:             get
<!--CRLF--> 
  33:             {
<!--CRLF--> 
  34:                 return new LocalValueEntry((DependencyProperty)propertyEnumerator.Key,
<!--CRLF--> 
  35:                   propertyEnumerator.Value);
<!--CRLF--> 
  36:             }
<!--CRLF--> 
  37:         }
<!--CRLF--> 
  38:
<!--CRLF--> 
  39:         object IEnumerator.Current
<!--CRLF--> 
  40:         {
<!--CRLF--> 
  41:             get { return this.Current; }
<!--CRLF--> 
  42:         }
<!--CRLF--> 
  43:
<!--CRLF--> 
  44:
<!--CRLF--> 
  45:         public bool MoveNext()
<!--CRLF--> 
  46:         {
<!--CRLF--> 
  47:             return propertyEnumerator.MoveNext();
<!--CRLF--> 
  48:         }
<!--CRLF--> 
  49:
<!--CRLF--> 
  50:         //重置propertyEnumerator
<!--CRLF--> 
  51:         public void Reset()
<!--CRLF--> 
  52:         {
<!--CRLF--> 
  53:             propertyEnumerator.Reset();
<!--CRLF--> 
  54:         }
<!--CRLF--> 
  55:
<!--CRLF--> 
  56:         public static bool operator !=(LocalValueEnumerator obj1, LocalValueEnumerator obj2)
<!--CRLF--> 
  57:         {
<!--CRLF--> 
  58:             throw new NotImplementedException();
<!--CRLF--> 
  59:         }
<!--CRLF--> 
  60:
<!--CRLF--> 
  61:         public static bool operator ==(LocalValueEnumerator obj1, LocalValueEnumerator obj2)
<!--CRLF--> 
  62:         {
<!--CRLF--> 
  63:             throw new NotImplementedException();
<!--CRLF--> 
  64:         }
<!--CRLF--> 
  65:
<!--CRLF--> 
  66:         public override bool Equals(object obj)
<!--CRLF--> 
  67:         {
<!--CRLF--> 
  68:             throw new NotImplementedException();
<!--CRLF--> 
  69:         }
<!--CRLF--> 
  70:
<!--CRLF--> 
  71:         public override int GetHashCode()
<!--CRLF--> 
  72:         {
<!--CRLF--> 
  73:             throw new NotImplementedException();
<!--CRLF--> 
  74:         }
<!--CRLF--> 
  75:     }
<!--CRLF--> 
  76:
<!--CRLF--> 
  77:     //LocalValue实体类
<!--CRLF--> 
  78:     public struct LocalValueEntry
<!--CRLF--> 
  79:     {
<!--CRLF--> 
  80:         private DependencyProperty property;
<!--CRLF--> 
  81:         private object value;
<!--CRLF--> 
  82:
<!--CRLF--> 
  83:         internal LocalValueEntry(DependencyProperty property, object value)
<!--CRLF--> 
  84:         {
<!--CRLF--> 
  85:             this.property = property;
<!--CRLF--> 
  86:             this.value = value;
<!--CRLF--> 
  87:         }
<!--CRLF--> 
  88:
<!--CRLF--> 
  89:         public DependencyProperty Property
<!--CRLF--> 
  90:         {
<!--CRLF--> 
  91:             get { return property; }
<!--CRLF--> 
  92:         }
<!--CRLF--> 
  93:
<!--CRLF--> 
  94:         public object Value
<!--CRLF--> 
  95:         {
<!--CRLF--> 
  96:             get { return value; }
<!--CRLF--> 
  97:         }
<!--CRLF--> 
  98:
<!--CRLF--> 
  99:         public static bool operator !=(LocalValueEntry obj1, LocalValueEntry obj2)
<!--CRLF--> 
 100:         {
<!--CRLF--> 
 101:             throw new NotImplementedException();
<!--CRLF--> 
 102:         }
<!--CRLF--> 
 103:
<!--CRLF--> 
 104:         public static bool operator ==(LocalValueEntry obj1, LocalValueEntry obj2)
<!--CRLF--> 
 105:         {
<!--CRLF--> 
 106:             throw new NotImplementedException();
<!--CRLF--> 
 107:         }
<!--CRLF--> 
 108:
<!--CRLF--> 
 109:         public override bool Equals(object obj)
<!--CRLF--> 
 110:         {
<!--CRLF--> 
 111:             throw new NotImplementedException();
<!--CRLF--> 
 112:         }
<!--CRLF--> 
 113:
<!--CRLF--> 
 114:         public override int GetHashCode()
<!--CRLF--> 
 115:         {
<!--CRLF--> 
 116:             throw new NotImplementedException();
<!--CRLF--> 
 117:         }
<!--CRLF--> 
 118:     }
<!--CRLF--> 
 119: }
<!--CRLF--> 
 120:
<!--CRLF-->

　　DependencyPropertyChangedEventArgs：PropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)的参数，它的第一个参数为该DependencyProperty、第二个参数为原来的值、第三个参数为改变了的值。

   1: using System;
<!--CRLF--> 
   2: using System.Collections.Generic;
<!--CRLF--> 
   3: using System.Linq;
<!--CRLF--> 
   4: using System.Text;
<!--CRLF--> 
   5:
<!--CRLF--> 
   6: namespace System.Windows
<!--CRLF--> 
   7: {
<!--CRLF--> 
   8:     public class DependencyPropertyChangedEventArgs
<!--CRLF--> 
   9:     {
<!--CRLF--> 
  10:         //第一个参数为该DependencyProperty、第二个参数为原来的值、第三个参数为新值
<!--CRLF--> 
  11:         public DependencyPropertyChangedEventArgs(DependencyProperty property, object oldValue, object newValue)
<!--CRLF--> 
  12:         {
<!--CRLF--> 
  13:             this.Property = property;
<!--CRLF--> 
  14:             this.OldValue = oldValue;
<!--CRLF--> 
  15:             this.NewValue = newValue;
<!--CRLF--> 
  16:         }
<!--CRLF--> 
  17:
<!--CRLF--> 
  18:         //注意所有的属性只对外界开放只读操作
<!--CRLF--> 
  19:         public object NewValue
<!--CRLF--> 
  20:         {
<!--CRLF--> 
  21:             get;
<!--CRLF--> 
  22:             private set;
<!--CRLF--> 
  23:         }
<!--CRLF--> 
  24:
<!--CRLF--> 
  25:         public object OldValue
<!--CRLF--> 
  26:         {
<!--CRLF--> 
  27:             get;
<!--CRLF--> 
  28:             private set;
<!--CRLF--> 
  29:         }
<!--CRLF--> 
  30:
<!--CRLF--> 
  31:         public DependencyProperty Property
<!--CRLF--> 
  32:         {
<!--CRLF--> 
  33:             get;
<!--CRLF--> 
  34:             private set;
<!--CRLF--> 
  35:         }
<!--CRLF--> 
  36:
<!--CRLF--> 
  37:         public override bool Equals(object obj)
<!--CRLF--> 
  38:         {
<!--CRLF--> 
  39:             if (!(obj is DependencyPropertyChangedEventArgs))
<!--CRLF--> 
  40:                 return false;
<!--CRLF--> 
  41:
<!--CRLF--> 
  42:             return Equals((DependencyPropertyChangedEventArgs)obj);
<!--CRLF--> 
  43:         }
<!--CRLF--> 
  44:
<!--CRLF--> 
  45:         public bool Equals(DependencyPropertyChangedEventArgs args)
<!--CRLF--> 
  46:         {
<!--CRLF--> 
  47:             return (Property == args.Property &&
<!--CRLF--> 
  48:                 NewValue == args.NewValue &&
<!--CRLF--> 
  49:                 OldValue == args.OldValue);
<!--CRLF--> 
  50:         }
<!--CRLF--> 
  51:
<!--CRLF--> 
  52:         public static bool operator !=(DependencyPropertyChangedEventArgs left, DependencyPropertyChangedEventArgs right)
<!--CRLF--> 
  53:         {
<!--CRLF--> 
  54:             throw new NotImplementedException();
<!--CRLF--> 
  55:         }
<!--CRLF--> 
  56:
<!--CRLF--> 
  57:         public static bool operator ==(DependencyPropertyChangedEventArgs left, DependencyPropertyChangedEventArgs right)
<!--CRLF--> 
  58:         {
<!--CRLF--> 
  59:             throw new NotImplementedException();
<!--CRLF--> 
  60:         }
<!--CRLF--> 
  61:
<!--CRLF--> 
  62:         public override int GetHashCode()
<!--CRLF--> 
  63:         {
<!--CRLF--> 
  64:             throw new NotImplementedException();
<!--CRLF--> 
  65:         }
<!--CRLF--> 
  66:
<!--CRLF--> 
  67:     }
<!--CRLF--> 
  68: }
<!--CRLF-->

DependencyPropertyKey：构造函数传入该DependencyProperty，然后通过Type来OverrideMetadata，此类只是起到了封装作用。

   1:
<!--CRLF--> 
   2: namespace System.Windows
<!--CRLF--> 
   3: {
<!--CRLF--> 
   4:     //构造函数传入该DependencyProperty，然后通过Type来OverrideMetadata
<!--CRLF--> 
   5:     public sealed class DependencyPropertyKey
<!--CRLF--> 
   6:     {
<!--CRLF--> 
   7:         internal DependencyPropertyKey (DependencyProperty dependencyProperty)
<!--CRLF--> 
   8:         {
<!--CRLF--> 
   9:             this.dependencyProperty = dependencyProperty;
<!--CRLF--> 
  10:         }
<!--CRLF--> 
  11:
<!--CRLF--> 
  12:         private DependencyProperty dependencyProperty;
<!--CRLF--> 
  13:         public DependencyProperty DependencyProperty {
<!--CRLF--> 
  14:             get { return dependencyProperty; }
<!--CRLF--> 
  15:         }
<!--CRLF--> 
  16:
<!--CRLF--> 
  17:         public void OverrideMetadata(Type forType, PropertyMetadata typeMetadata)
<!--CRLF--> 
  18:         {
<!--CRLF--> 
  19:             dependencyProperty.OverrideMetadata (forType, typeMetadata, this);
<!--CRLF--> 
  20:         }
<!--CRLF--> 
  21:     }
<!--CRLF--> 
  22: }
<!--CRLF-->

　　DependencyObjectType：用静态Dictionary<Type, DependencyObjectType>来存储DependencyObjectType，主要有FromSystemType、IsInstanceOfType和IsSubclassOf三个功能。

   1: using System;
<!--CRLF--> 
   2: using System.Collections.Generic;
<!--CRLF--> 
   3: using System.Linq;
<!--CRLF--> 
   4: using System.Text;
<!--CRLF--> 
   5:
<!--CRLF--> 
   6: namespace System.Windows
<!--CRLF--> 
   7: {
<!--CRLF--> 
   8:     public class DependencyObjectType
<!--CRLF--> 
   9:     {
<!--CRLF--> 
  10:         //键为Type（即OwnerType），值为DependencyObjectType（即ID和systemType）的键值对
<!--CRLF--> 
  11:         private static Dictionary<Type, DependencyObjectType> typeMap = new Dictionary<Type, DependencyObjectType>();
<!--CRLF--> 
  12:         private static int current_id;
<!--CRLF--> 
  13:
<!--CRLF--> 
  14:         private int id;
<!--CRLF--> 
  15:         private Type systemType;
<!--CRLF--> 
  16:
<!--CRLF--> 
  17:         //构造函数私有，在FromSystemType里进行构造，初始化id和systemType
<!--CRLF--> 
  18:         private DependencyObjectType(int id, Type systemType)
<!--CRLF--> 
  19:         {
<!--CRLF--> 
  20:             this.id = id;
<!--CRLF--> 
  21:             this.systemType = systemType;
<!--CRLF--> 
  22:         }
<!--CRLF--> 
  23:
<!--CRLF--> 
  24:         //基类型的DependencyObjectType
<!--CRLF--> 
  25:         public DependencyObjectType BaseType
<!--CRLF--> 
  26:         {
<!--CRLF--> 
  27:             get { return DependencyObjectType.FromSystemType(systemType.BaseType); }
<!--CRLF--> 
  28:         }
<!--CRLF--> 
  29:
<!--CRLF--> 
  30:         public int Id
<!--CRLF--> 
  31:         {
<!--CRLF--> 
  32:             get { return id; }
<!--CRLF--> 
  33:         }
<!--CRLF--> 
  34:
<!--CRLF--> 
  35:         public string Name
<!--CRLF--> 
  36:         {
<!--CRLF--> 
  37:             get { return systemType.Name; }
<!--CRLF--> 
  38:         }
<!--CRLF--> 
  39:
<!--CRLF--> 
  40:         public Type SystemType
<!--CRLF--> 
  41:         {
<!--CRLF--> 
  42:             get { return systemType; }
<!--CRLF--> 
  43:         }
<!--CRLF--> 
  44:
<!--CRLF--> 
  45:         //用静态Dictionary<Type, DependencyObjectType>来存储DependencyObjectType
<!--CRLF--> 
  46:         public static DependencyObjectType FromSystemType(Type systemType)
<!--CRLF--> 
  47:         {
<!--CRLF--> 
  48:             if (typeMap.ContainsKey(systemType))
<!--CRLF--> 
  49:                 return typeMap[systemType];
<!--CRLF--> 
  50:
<!--CRLF--> 
  51:             DependencyObjectType dot;
<!--CRLF--> 
  52:
<!--CRLF--> 
  53:             typeMap[systemType] = dot = new DependencyObjectType(current_id++, systemType);
<!--CRLF--> 
  54:
<!--CRLF--> 
  55:             return dot;
<!--CRLF--> 
  56:         }
<!--CRLF--> 
  57:
<!--CRLF--> 
  58:         //是否是该DependencyObject的子类实例
<!--CRLF--> 
  59:         public bool IsInstanceOfType(DependencyObject d)
<!--CRLF--> 
  60:         {
<!--CRLF--> 
  61:             return systemType.IsInstanceOfType(d);
<!--CRLF--> 
  62:         }
<!--CRLF--> 
  63:
<!--CRLF--> 
  64:         //该DependencyObjectType是否是传入DependencyObjectType的子实例
<!--CRLF--> 
  65:         public bool IsSubclassOf(DependencyObjectType dependencyObjectType)
<!--CRLF--> 
  66:         {
<!--CRLF--> 
  67:             return systemType.IsSubclassOf(dependencyObjectType.SystemType);
<!--CRLF--> 
  68:         }
<!--CRLF--> 
  69:
<!--CRLF--> 
  70:         public override int GetHashCode()
<!--CRLF--> 
  71:         {
<!--CRLF--> 
  72:             throw new NotImplementedException();
<!--CRLF--> 
  73:         }
<!--CRLF--> 
  74:     }
<!--CRLF--> 
  75: }
<!--CRLF--> 
  76:
<!--CRLF-->

十四. 回归并统计覆盖率

　　在上面的开发过程中，我们会不断的运行和查看代码通过情况，最后我们也来看一下测试用例的总体通过情况，其实在前面已经运行过很多次了，因为每个功能都要经过”测试代码－功能代码－测试－重构“等步骤。

WPF基础到企业应用系列8——依赖属性之“风云再起”_第5张图片

　　最后也看一下代码测试覆盖率，代码测试覆盖率对一个系统或者产品来说是一个比较重要的质量指标，可以通过它看出系统的稳定性和可控性。一般在项目的开发中，我们都会以85%~90%的测试代码覆盖率作为达标的参考标准。

WPF基础到企业应用系列8——依赖属性之“风云再起”_第6张图片

　　由于MONO本身对依赖属性没有那么健全，我们也没有写那么详细的测试代码，中间直接就实现了一些功能，严格地说，所以本文并没有完全遵从正规的测试驱动开发流程。

十五. 简单验证依赖属性系统

其实通过上面的测试用例，基本就用不着再单独测试了，但鉴于覆盖率比较低的问题，所以最后我们还是来测试一下刚才构建的依赖属性系统：

   1: class Program
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:     static void Main(string[] args)
<!--CRLF--> 
   4:     {
<!--CRLF--> 
   5:         SimpleDPClass sDPClass = new SimpleDPClass();
<!--CRLF--> 
   6:         sDPClass.SimpleDP = 8;
<!--CRLF--> 
   7:         Console.ReadLine();
<!--CRLF--> 
   8:     }
<!--CRLF--> 
   9: }
<!--CRLF--> 
  10:
<!--CRLF--> 
  11: public class SimpleDPClass : DependencyObject
<!--CRLF--> 
  12: {
<!--CRLF--> 
  13:     public static readonly DependencyProperty SimpleDPProperty =
<!--CRLF--> 
  14:         DependencyProperty.Register("SimpleDP", typeof(double), typeof(SimpleDPClass),
<!--CRLF--> 
  15:             new PropertyMetadata((double)0.0,
<!--CRLF--> 
  16:
<!--CRLF--> 
  17:                 new PropertyChangedCallback(OnValueChanged),
<!--CRLF--> 
  18:                 new CoerceValueCallback(CoerceValue)),
<!--CRLF--> 
  19:                 new ValidateValueCallback(IsValidValue));
<!--CRLF--> 
  20:
<!--CRLF--> 
  21:     public double SimpleDP
<!--CRLF--> 
  22:     {
<!--CRLF--> 
  23:         get { return (double)GetValue(SimpleDPProperty); }
<!--CRLF--> 
  24:         set { SetValue(SimpleDPProperty, value); }
<!--CRLF--> 
  25:     }
<!--CRLF--> 
  26:
<!--CRLF--> 
  27:     private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
<!--CRLF--> 
  28:     {
<!--CRLF--> 
  29:         Console.WriteLine("当值改变时，我们可以做的一些操作，具体可以在这里定义： {0}", e.NewValue);
<!--CRLF--> 
  30:     }
<!--CRLF--> 
  31:
<!--CRLF--> 
  32:     private static object CoerceValue(DependencyObject d, object value)
<!--CRLF--> 
  33:     {
<!--CRLF--> 
  34:         Console.WriteLine("对值进行限定，强制值： {0}", value);
<!--CRLF--> 
  35:         return value;
<!--CRLF--> 
  36:     }
<!--CRLF--> 
  37:
<!--CRLF--> 
  38:     private static bool IsValidValue(object value)
<!--CRLF--> 
  39:     {
<!--CRLF--> 
  40:         Console.WriteLine("验证值是否通过，如果返回True表示验证通过，否则会以异常的形式暴露： {0}", value);
<!--CRLF--> 
  41:         return true;
<!--CRLF--> 
  42:     }
<!--CRLF--> 
  43:
<!--CRLF--> 
  44: }
<!--CRLF-->

测试结果：

WPF基础到企业应用系列8——依赖属性之“风云再起”_第7张图片

到处为止，我们这篇文章也宣告结束。

十六. 本文总结

　　本篇承接上一篇WPF基础到企业应用系列7——深入剖析依赖属性的写作风格，对上篇模拟一个WPF依赖属性的实现重现演绎了一遍，上篇是根据微软WPF的BCL源码剖析的，所以这篇我们就详细的研究一下.NET的跨平台版本MONO关于依赖属性系统的实现。在这篇文章中，我只是起到了剖析源码的作用，就像研究微软的BCL一样，不过MONO的代码远没有微软的BCL那么庞大，所以研究和复原起来不是很吃力。如果大家还想继续深入，可以去下载相关源码，也希望大家和我一起交流探讨。

十七. 相关代码下载

　　在文章的最后，和往常一样，我们提供代码的下载，再次温馨提示：这几篇文章最重要的就是下载代码来细细研究，代码里面也添加了比较详细的注释，如果大家有什么问题，也可以直接和我联系，如果有不正确的地方也希望多多海涵并能给我及时反馈，我将感激不尽！

WPF基础到企业应用系列8——依赖属性之“风云再起”_第8张图片
上图就是整个代码包的结构图，下载链接：DependencySystem.rar

十八.系列进度

前篇

· 1. WPF 基础到企业应用系列1——开篇有益

· 2. WPF 基础到企业应用系列2——WPF前世今生

· 3. WPF 基础到企业应用系列3——WPF开发漫谈

· 4. WPF 基础到企业应用系列4——WPF千年轮回

· 5. WPF 基础到企业应用系列5——WPF千年轮回 续前缘

· 6. WPF 基础到企业应用系列6——WPF布局全接触

· 7. WPF 基础到企业应用系列7——深入剖析依赖属性（核心篇）

· 8. WPF 基础到企业应用系列8——依赖属性之“风云再起”

· 9. WPF 基础到企业应用系列9——深入剖析WPF事件机制 （核心篇）

·10. WPF 基础到企业应用系列10——WPF事件机制之“刨根问底”

·11. WPF 基础到企业应用系列11——深入剖析WPF命令机制 （核心篇）

·12. WPF 基础到企业应用系列12——WPF命令之“庖丁解牛”

·13. WPF 基础到企业应用系列13——WPF Binding全接触 （核心篇）

·14. WPF 基础到企业应用系列14——WPF Binding之“面面俱到”

中篇

· 1. 资源、样式、模板

· 2. 尺寸缩放、定位与变换元素

· 3. WPF控件分类介绍与使用技巧

· 4. 用户控件和自定义控件开发

· 5. 多语言、皮肤和主题

· 6. 2D图形

· 7. 3D图形

· 8. 动画（几种动画的应用）

· 9. 音频、视频、语音

· 10. 文档、打印、报表

后篇

· 1. Win32、Windows Form以及ActiveX之间的互用性

· 2. 构建并部署应用程序（ClickOnce部署、微软setup /InstallShield+自动更新组件）

· 3. MVC、MVP、MVVM全解析

· 4. WPF的模式讲解及实例（MVC Demo）

· 5. WPF的模式讲解及实例（MVP Demo）

· 6. WPF的模式讲解及实例（MVVM Demo）

· 7. 性能优化（WPF项目的瓶颈）

· 8.一个完整WPF项目（普通架构版）

· 9. 一个完整WPF项目（MVVM架构版）

· 10. WPF 4.0新功能

云计算专区（http://home.cnblogs.com/group/CloudComputing/），如果大家有什么云计算相关的疑问或话题也可以在里面进行探讨。由于圣殿骑士以后会定格和专注于这几个方向，所以很希望同大家一起交流和进步！

你可能感兴趣的:(企业应用)

  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗? 瑞金彭于晏 springboot后端javaMVCspring数据库
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
  • SpringSecurity初学总结 weixin_66442229 spring
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
  • PON光模块的独特类型和特性 audrey-luo 网络光模块PON模块PON技术
    在当前互联网需求快速增长的背景下，PON光模块已成为实现光纤网络高速数据传输的重要组成部分。从住宅宽带到各种企业应用程序解决方案，PON光模块始终致力于实现高质量的数据传输与无缝通信。了解PON光模块的类型和特性对于深入理解现代网络基础设施至关重要，本文将探讨PON光模块的多种类型及其独特优势，展示其在现代网络连接中的重要作用。PON光模块又称无源光网络模块，是电信网络中的关键组件，有助于通过光纤
  • 【2023年】云计算金砖牛刀小试3 geekgold 云计算linux运维容器kubernetes云原生
    A场次题目：OpenStack平台部署与运维业务场景：某企业拟使用OpenStack搭建一个企业云平台，用于部署各类企业应用对外对内服务。云平台可实现IT资源池化，弹性分配，集中管理，性能优化以及统一安全认证等。系统结构如下图：企业云平台的搭建使用竞赛平台提供的两台云服务器，配置如下表：设备名称主机名接口ip地址云服务器1controllereth0，eth1私网：192.168.100.10/2
  • 解锁Apache Shiro：新手友好的安全框架指南(一)——整体架构与身份认证_apache shiro的配置包括安全管理器(2) 2401_84281748 程序员apache安全架构
    ApacheShiro是一个功能强大且易于使用的Java安全框架，它执行身份验证、授权、加密和会话管理，可用于保护任何应用程序——从命令行应用程序、移动应用程序到最大的web和企业应用程序。Shiro提供了应用程序安全API来执行以下方面：Authentication（认证）：验证用户身份，即用户登录。Authorization（授权）：访问控制Cryptography（密码学）：保护或隐藏私密数
  • 中间件的学习理解总结 DCDDDDcccc 中间件学习
    目录一、定义与作用二、主要类型数据库中间件远程过程调用中间件面向消息的中间件事务处理中间件三、特点与优势独立性高效性可扩展性可靠性四、应用场景企业应用集成分布式系统电子商务移动应用开发五、数据库中间件功能细节：应用优势：六、远程过程调用中间件功能细节：应用优势：七、面向消息的中间件功能细节：应用优势：八、事务处理中间件功能细节：应用优势：数据库中间件MyCat：ShardingSphere：远程过
  • 纯干货！快收藏！大模型技术应用架构演进 AI大模型_学习君 架构人工智能ai语言模型gpu算力科技大模型
    大模型应用技术架构话不多说，直接上干货，让我们来看看那些隐藏在应用背后，现在大模型都有哪些常用的架构模式，可以为您的企业应用建设提供参考：V1、直接调用大模型这种是最简单的方式，通过prompt给到大模型直接拿到结果。如果只有一个大模型并且用的是别人的公有大模型，那基本上就是大家所说的“套壳”。V2、FunctionCalling调用API无论什么AI大模型，其本身是有局限性的，例如无法获取实时的
  • 企业财税自动化解决方案的安全与合规性保障 金智维科技官方 自动化安全大数据
    数字化时代，企业财税管理正逐步向自动化、智能化转型，RPA自动化技术由于能够自动处理大量重复性、具备规则性的工作流程任务，极大地提高企业财税工作的效率和准确性，成为各企业财务转型的首选方案。然而，在采用财税自动化解决方案的过程中，如何确保数据的安全性和合规性也成为企业不可忽视的重要问题。本文金智维将探讨企业应用财税自动化解决方案时如何保障财务数据安全与合规性，为企业提供可靠的参考和指导。1.数据加
  • Oracle数据库高级技术探索与应用 我的运维人生 oracle数据库运维开发技术共享
    Oracle数据库高级技术探索与应用在数据库技术领域，Oracle数据库以其强大的性能、可靠性和灵活性，成为众多企业应用的首选。本文将从Oracle数据库的连接、查询优化、常见操作及高级功能四个方面展开，通过具体的代码示例，深入探讨Oracle数据库的高级技术与应用。一、Oracle数据库的连接在进行任何数据库操作之前，首先需要建立与Oracle数据库的连接。Python作为一种流行的编程语言，通
  • 上云必备！阿里云为企业用户提供易用、精选、一站式的企业应用产品 阿里云最新优惠和活动汇总
    阿里云为企业用户提供企业上云、企业建站、企业安全、企业数据、企业营销等场景下的易用、精选、一站式的企业应用，精选企业热门产品，为您提供一站式上云服务，满足各个发展阶段的软硬件需求。上云必备福利：阿里云产品通用代金券领取地址：阿里云官方云小站代金券可用于购买阿里云产品时直接抵扣现金使用。云小站代金券.jpg企业上云需要哪些云产品？阿里云提供易用、精选、一站式的企业应用上云热门云产品如下：一、企业上云
  • 【摸鱼笔记】python 提取和采集 finereport 未绑定目录的报表模板 The_Singing_Towers 笔记python开发语言
    背景在企业应用过程中，报表一般会按照数据分析的主题、项目将多个报表放在一处，一些图表类报表会有通过超链接等方式，跳转到对应的明细报表中。并且在正式的使用中，这些报表不会绑定到目录。在梳理数据分析项目使用情况时这些报表会难以辨认所属的项目，因为即使按照很标准的方式【将同一项目的报表放在同一目录】也会有数据分析项目相互包含的问题影响梳理的工作量。同时在finelogDB的访问记录中displayNam
  • JavaEE笔记1 Ouwly
    目标1.认识JavaEEJava语言分为三大类1.JavaSE2.JavaME3.JavaEEJavaSE，标准版，主要用于开发和部署桌面、服务器以及嵌入设备和实时环境中的Java应用程序。例如，Java应用程序开发平台Eclipse。JavaEE，企业版，主要针对企业应用的开发。例如，电子商务网站、ERP系统。JavaME，微型版，主要针对消费类电子设备的。例如，蜂窝电话和可视电话、数字机顶盒、
  • 智能未来：低代码与AI如何重塑企业应用开发 HUIBUR科技 低代码平台AI企业应用开发低代码ai
    引言在当今瞬息万变的商业环境中，企业面临着前所未有的挑战与机遇。数字化转型已经成为各行各业的必然趋势，而在这一过程中，应用开发的效率与智能化程度成为企业竞争力的重要衡量标准。传统的开发模式往往需要大量的时间和资源，而低代码平台的兴起则为企业提供了一条更加敏捷、灵活的开发路径。与此同时，人工智能（AI）技术，尤其是大规模语言模型的进步，为应用程序赋予了前所未有的智能化能力。然而，单靠低代码或AI技术
  • 提高 Web 应用程序安全性的标准 网络研究观 网络研究观网络安全信息应用程序标准OWASP
    开放式Web应用程序安全项目(OWASP)是一个国际非营利组织，致力于为任何有兴趣提高Web应用程序安全性的人提供免费文档、工具、视频和论坛。OWASP最初成立为开放式Web应用程序安全项目，并于2004年注册为非营利性慈善机构，提供有关最佳实践的公正建议并推动开放标准的创建。如今，OWASP致力于帮助开发人员编写更好的软件，并让安全专业人员能够提高软件的安全性，认识到企业应用程序是企业数字运营的
  • 打脸预测，AI泡沫破裂，科技衰退 齐玉林 人工智能科技
    首先抛出我的观点，AI的方向是好的，但大模型并不是好的实现路径。作为AI功能的体验者，我并没觉得AI为我的生活、工作、学习做了哪些重大的改变，经常看到各大媒体报道谁谁谁又开源了某项AI大模型，谁谁又做出了AI级企业应用，性能提升百分之几百。看到这些五花八门的标题都没有点进去看的兴趣，20年人工智能兴起，也让我知道世界上还有这么个玩意，这4年一路走来AI的创业公司陆陆续续倒下8万多家，全球接近20万
  • 客服智能管理系统是如何应用的 呼叫易 呼叫中心系统电话系统
    客服系统有很多种类，针对不同场景的客服使用的客服系统也不同，如有网店里的在线客服、实体店里的电话客服、网站上的在线客服、公共服务型的热线客服、售后服务客服等等。所谓客服智能管理系统就是一种可以把多个客服场景都管理起来的系统，提高企业的工作效率。这样一款强大功能的呼叫中心客服智能管理系统（以下简称：智能客服系统），在企业应用中能够发挥什么作用呢？智能客服系统也是新型呼叫中心系统，已实现了全渠道接入，
  • Visual Basic：企业级应用开发的稳健之选 2401_85760095 数据库
    标题：VisualBasic：企业级应用开发的稳健之选在当今多样化的编程语言生态中，VisualBasic（VB）和其.NET版本VB.NET，依旧在企业级应用开发中占有一席之地。尽管新兴语言和技术不断涌现，VB.NET以其简洁的语法、易于学习和使用的特点，以及与.NET框架的深度集成，继续在企业应用领域发挥着重要作用。本文将探讨VB.NET在企业级应用开发中的地位，并展示其在实际开发中的运用。1
  • Java中的BPM与工作流引擎详解 ๑҉ 晴天 javajava开发语言
    业务流程管理（BusinessProcessManagement，BPM）和工作流引擎在现代企业应用中扮演着关键角色。它们帮助自动化和优化业务流程，提高工作效率。在Java生态系统中，有多个BPM和工作流引擎可供选择，如Activiti和Camunda。本文将详细介绍BPM的基本概念，探讨Activiti和Camunda这两种流行的工作流引擎，并提供一个代码示例展示如何在Java中集成和使用工作流
  • 大模型企业应用落地系列三》基于大模型的对话式推荐系统》技术架构实现》大数据平台层 陈敬雷-充电了么-CEO兼CTO 算法人工智能大数据架构大数据aichatgptgptgpt-3nlp
    注：此文章内容均节选自充电了么创始人，CEO兼CTO陈敬雷老师的新书《自然语言处理原理与实战》（人工智能科学与技术丛书）【陈敬雷编著】【清华大学出版社】文章目录大模型企业应用落地系列三技术架构实现》大数据平台层大模型底座层具体实现大模型推荐技术发展趋势探讨总结大模型企业应用落地系列三技术架构实现》大数据平台层大数据平台层是对话式推荐系统的重要基础，它集成了多种数据库和数据存储技术，以满足系统对数据
  • 大模型企业应用落地系列》基于大模型的对话式推荐系统》技术架构设计全攻略 陈敬雷-充电了么-CEO兼CTO 算法人工智能大数据gpt人工智能chatgptgpt-3推荐算法搜索引擎ai
    注：此文章内容均节选自充电了么创始人，CEO兼CTO陈敬雷老师的新书《自然语言处理原理与实战》（人工智能科学与技术丛书）【陈敬雷编著】【清华大学出版社】文章目录大模型企业应用落地系列全貌基于大模型的对话式推荐系统》技术架构设计全攻略基于大模型的对话式推荐系统项目实践大模型推荐技术发展趋势探讨总结大模型企业应用落地系列全貌基于大模型的对话式推荐系统》技术架构设计全攻略从传统推荐系统到基于大模型的对话
  • 大模型企业应用落地系列一》基于大模型的对话式推荐系统》对话式推荐系统概述 陈敬雷-充电了么-CEO兼CTO 人工智能算法大数据nlp推荐算法搜索引擎自然语言处理chatgptgpt-3ai
    注：此文章内容均节选自充电了么创始人，CEO兼CTO陈敬雷老师的新书《自然语言处理原理与实战》（人工智能科学与技术丛书）【陈敬雷编著】【清华大学出版社】文章目录大模型企业应用落地系列一基于大模型的对话式推荐系统》对话式推荐系统概述对话式推荐系统技术架构设计大模型推荐技术发展趋势探讨总结大模型企业应用落地系列一基于大模型的对话式推荐系统》对话式推荐系统概述在当今AI时代，大模型技术正引领着企业应用的
  • 大模型应用：大模型AI Agent在企业应用中的6种基础类型，企业智慧升级必备 汀、人工智能 LLM技术汇总人工智能promptLLM自然语言处理大模型NL2SQL
    大模型应用：大模型AIAgent在企业应用中的6种基础类型，企业智慧升级必备AIAgent智能体在企业应用中落地的价值、场景、成熟度做了分析，并且探讨了未来企业IT基础设施与架构如何为未来GenAI（生成式AI）做好准备。在这样的架构中，把最终体现上层应用能力的AIAgent从不同的技术要求与原理上分成了几类：创作与生成类助手企业知识助手数据分析助手应用/工具助手Web操作助手自定义流程助手1.创
  • 【人工智能时代】- 深度解析AI大语言模型（LLM）在企业应用的关键技术与典型架构 xiaoli8748_软件开发 人工智能时代人工智能语言模型架构
    大语言模型（LLM）的出现，使基于自然语言处理的人工智能技术实现了飞跃式的发展，彻底开启了AI2.0的时代。随着大模型的不断迭代与升级，周边生态的培育与成熟，其在B端企业级场景的落地应用也逐渐拉开序幕。本文将对大模型在企业应用中的落地场景、典型架构与产品选择等做较深入的探讨与分析。由于内容较长，本文将分为上下两篇做完整阐述。LLM在企业应用的落地场景当然，我们说的企业应用场景不是指的企业内个人使用
  • 基于AngularJS的企业软件前端架构 weixin_33980459 前端javascript后端ViewUI
    2019独角兽企业重金招聘Python工程师标准>>>这篇是我参加QCon北京2014的演讲内容：提纲：企业应用在软件行业中占有很大的比重，而这类软件多数现在也都采用B/S的模式开发，在这个日新月异的时代，它们的前端开发技术找到了什么改进点呢？B/S企业软件前端开发模式大体上与桌面软件类似，都是偏重量级的，在前端可能会有较多的业务逻辑，这些业务逻辑如何被合理模块化，与界面分离，以便测试，成为这个领
  • 面向企业 SaaS 应用程序的应用程序性能管理 ManageEngine卓豪 应用性能监控应用程序性能管理APM应用性能监控
    企业应用程序需要高度的可扩展性来满足庞大的最终用户群，这些组织中的IT团队面临的首要问题是监控正常运行时间并确保其业务应用程序的良好性能，为了解决这些问题，企业需要对端到端应用程序性能管理工具进行战略投资，使IT运营团队能够交付满足客户期望的业务应用程序。企业使用的应用程序类型将CRM、联系人管理、订单跟踪等关键业务应用程序迁移到云端是一种趋势，这种趋势正在迅速发展，特别是因为它对移动劳动力的生产
  • 软件开发者必读！2024年30大趋势提前曝光！
    软件是科技行业的基础。从智能手机到复杂的企业系统，软件是推动这些技术的核心。在探索数字时代的过程中，了解软件开发的趋势非常重要。人工智能、机器学习、物联网等技术的快速发展对软件开发行业产生了巨大影响。本文旨在通过30个数据汇总，帮助读者们初步了解2024年软件开发领域的新趋势。软件开发市场概况1、软件行业84.70%的公司专注于为客户开发企业应用程序。2、53.90%的公司主要从事业务流程自动化的
  • 【在Linux世界中追寻伟大的One Piece】Linux是从哪里来的？又是怎么发展的？基本指令你知道哪些？ 枫叶丹4 Linuxlinux运维服务器后端
    目录1->Linux背景1.1->Linux发展史1.1.1->UNIX发展历史1.1.2->Linux发展历史1.2->开源1.3->官网1.4->企业应用现状1.5->发行版本1.6->OS概念，定位2->Linux下基本指令2.1->Is指令2.2->pwd指令2.3->cd指令2.4->touch指令2.5->mkdir指令2.6->rmdir指令&&rm指令2.7->man指令2.8->
  • Gartner：2018年CRM软件市场增长15.6% 穿背心儿的程序猿
    【TechWeb】6月19日，Gartner发布的最新研究显示，全球客户体验与关系管理（CRM）软件支出在2018年增长15.6%，达到482亿美元。CRM仍是最大且增长最快的企业应用软件。数据显示，2018年，全球企业应用软件收入总额超过1936亿美元，与2017年的1721亿美元相比，增幅达到12.5%。CRM占企业应用软件收入总额的近四分之一。前五大CRM软件厂商占2018年市场总额的40%
  • 【SpringBoot3】Spring Security 核心概念 顽石九变 SpringBoot3.0从入门到精通springjavaSpringBootspringsecurity
    一、什么是SpringSecurity注：本文基于SpringBoot3.2.1以及SpringSecurity6.2.1SpringSecurity是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了SpringIoC、DI（依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问
  • apache ftpserver-CentOS config gengzg apache
    <server xmlns="http://mina.apache.org/ftpserver/spring/v1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://mina.apache.o
  • 优化MySQL数据库性能的八种方法 AILIKES sqlmysql
    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
  • JeeSite 企业信息化快速开发平台 Kai_Ge JeeSite
    JeeSite 企业信息化快速开发平台 平台简介 JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。 JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
  • 通过Spring Mail Api发送邮件 120153216 邮件main
    原文地址：http://www.open-open.com/lib/view/open1346857871615.html 使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】 Spring Mail API都在org.spri
  • Pysvn 程序员使用指南 2002wmj SVN
    源文件:http://ju.outofmemory.cn/entry/35762 这是一篇关于pysvn模块的指南. 完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html. pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个. 该
  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL 357029540 SQL Server
    SELECT  R.session_id AS BlockedSessionID ,          S.session_id AS BlockingSessionID ,          Q1.text AS Block
  • Intent 常用的用法备忘 7454103 .netandroidGoogleBlogF#
    Intent     应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。 下面列出几种Intent 的用法 显示网页:
  • Spring定时器时间配置 adminjun spring时间配置定时器
    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" /> 测试的时候，由于是每天定时执行，所以后面三个数
  • POJ 2421 Constructing Roads 最小生成树 aijuans 最小生成树
    来源：http://poj.org/problem?id=2421 题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。 思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。 代码： #include <iostream> #include <cstdio>
  • 重构笔记——提取方法（Extract Method） ayaoxinchao java重构提炼函数局部变量提取方法
    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。   下面是我学习这个重构手法的笔记：   提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
  • 为UILabel添加点击事件 bewithme UILabel
        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。   UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例) bijian1013 redis数据库NoSQL
    一.redis.php <?php //实例化 $redis = new Redis(); //连接服务器 $redis->connect("localhost"); //授权 $redis->auth("lamplijie"); //相关操
  • SecureCRT使用备注 bingyingao secureCRT每页行数
    SecureCRT日志和卷屏行数设置 一、使用securecrt时，设置自动日志记录功能。 1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs； 2、点击Options -> Global Options -> Default Session -> Edite Default Sett
  • 【Scala九】Scala核心三：泛型 bit1129 scala
    泛型类 package spark.examples.scala.generics class GenericClass[K, V](val k: K, val v: V) { def print() { println(k + "," + v) } } object GenericClass { def main(args: Arr
  • 素数与音乐 bookjovi 素数数学haskell
        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。     闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
  • Java-Collections Framework学习与总结-IdentityHashMap BrokenDreams Collections
            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。         简单的说，IdentityHashMap和HashM
  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java
  • PS人像润饰&调色教程集锦 cherishLC PS
      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓 http://www.howzhi.com/course/retouching/   新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。   所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
  • 更新多个字段的UPDATE语句 crabdave update
    更新多个字段的UPDATE语句                    update tableA a set (a.v1, a.v2, a.v3, a.v4) = --使用括号确定更新的字段范围
  • hive实例讲解实现in和not in子句 daizj hivenot inin
    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html 当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。 假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
  • 一道24点的10+种非人类解法（2,3,10,10） dsjt 算法
    这是人类算24点的方法？！！！ 事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态 朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。 然后么。。。我就在深夜很得瑟的问室友求室友算 刚出完题，文哥的暴走之旅开始了 5秒后
  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题 dcj3sjt126com yiiframework
    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
  • 对象与关系之间的矛盾：“阻抗失配”效应[转] come_for_dream 对象
    概述   “阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。   “阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
  • 学习编程那点事 gcq511120594 编程互联网
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
  • Reverse Linked List II hcx2013 list
    Reverse a linked list from position m to n. Do it in-place and in one-pass. For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, return 
  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • Hadoop集群工具distcp liyonghui160com
        1. 环境描述 两个集群：rock 和 stone rock无kerberos权限认证，stone有要求认证。 1. 从rock复制到stone，采用hdfs Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
  • 一个备份MySQL数据库的简单Shell脚本 pda158 mysql脚本
    　　主脚本（用于备份mysql数据库）： 　　该Shell脚本可以自动备份 数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。 　　 1. 分别建立目录“backup”和“oldbackup” 　　#mkdir /backup 　　#mkdir /oldbackup 　
  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇 shoothao IT资源图标库图片库色彩板字体
    A. 免费的设计资源 Freebbble:来自于Dribbble的免费的高质量作品。 Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。 Graphic Burger:每个像素点都做得很细的绝佳的设计资源。 Pixel Buddha:免费和优质资源的专业社区。 Premium Pixels:为那些有创意的人提供免费的素材。
  • thrift总结 - 跨语言服务开发 uule thrift
    官网 官网JAVA例子 thrift入门介绍 IBM-Apache Thrift - 可伸缩的跨语言服务开发框架 Thrift入门及Java实例演示 thrift的使用介绍   RPC    POM： <dependency> <groupId>org.apache.thrift</groupId>
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他