1 (p0-1): 第0章 导读 1 (p0-2): 目录 7 (p0-3): 第1章 一个简单的想法 13 (p0-4): 1.1 找寻问题的本质 15 (p0-5): 1.2 搜寻解决方法 15 (p0-6): 1.2.1 面向对象开发方法 16 (p0-7): 1.2.2 测试驱动开发(TDD-Test-Driven Development) 16 (p0-8): 1.2.3 结合面向对象分析/面向对象设计和XP/TDD 17 (p0-9): 1.3 结论 19 (p0-10): 第2章 分析和设计架构的思考 19 (p0-11): 2.1 从自然的场景开始构思 22 (p0-12): 2.2.1 需求捕获 22 (p0-13): 2.2 PFM系统的设计 24 (p0-14): 2.2.2 使用需求分析 27 (p0-15): 2.2.3 产品设计 34 (p0-16): 2.3 类架构的思考 35 (p0-17): 2.4 建立开发环境 36 (p0-18): 2.4.1 建立版本控制项目 43 (p0-19): 2.5 结论 45 (p0-20): 第3章 TDD和NUnit框架 45 (p0-21): 3.1 取得NUnit For.NET 46 (p0-22): 3.2 测试驱动开发模型 47 (p0-23): 3.3 使用NUnit框架 48 (p0-24): 3.3.1 范例场景 49 (p0-25): 3.3.2 在C#项目中使用NUnit 50 (p0-26): 3.3.3 使用NUnit框架建立测试用例 62 (p0-27): 3.3.4 NUnit框架提供测试服务的函数 63 (p0-28): 3.3.5 使用测试包(Test Suite) 68 (p0-29): 3.3.6 测试种类(Test Category) 74 (p0-30): 3.4 结论 77 (p0-31): 第4章 执行引擎和XML驱动设计 78 (p0-32): 4.1 设计架构的思考 83 (p0-33): 4.2 设定本章开发项目 87 (p0-34): 4.3 封装配置信息类设计 88 (p0-35): 4.3.1 TPFMConfig类的设计 91 (p0-36): 4.3.2 TPFMConfigManager类的设计 93 (p0-37): 4.3.3 TPFMSchedule类设计 94 (p0-38): 4.3.4 TPFMScheduleManager类设计 96 (p0-39): 4.4 从面向对象分析/设计转换到XP/TDD 97 (p0-40): 4.4.1 TPFMConfigManager类实现 101 (p0-41): 4.4.2 TPFMScheduleManager类实现 104 (p0-42): 4.4.3 建立测试用例测试设计和实现的类 111 (p0-43): 4.5 观察到父类的迹象 114 (p0-44): 4.5.1 设计TPFMManager 119 (p0-45): 4.5.2 使用TDD测试TPFMManager 122 (p0-46): 4.6 改善和重构TPFMManager类 131 (p0-47): 4.7 使用Together检查程序代码质量 140 (p0-48): 4.8 类使用的设计模式 142 (p0-49): 4.9 我们学到了什么 143 (p0-50): 4.10 开发周期管理 146 (p0-51): 4.11 另外一种开发配置 148 (p0-52): 4.12 结论 151 (p0-53): 第5章 多元,弹性架构的设计和实现——Handlers 152 (p0-54): 5.1 设计架构的思考 159 (p0-55): 5.2 设定本章开发项目 160 (p0-56): 5.3 处理器接口和处理器类的设计和实现 163 (p0-57): 5.4 处理器类派生类设计和实现 164 (p0-58): 5.4.1 文件处理器类-TPFMFileHandler 167 (p0-59): 5.4.2 压缩和反压缩处理器类-TPFMZipHandler 175 (p0-60): 5.4.3...

zlibzh/no-category/李维著, 李维著, 李维/面向对象开发实践之路 C#版_116971362.pdf

Practical Object-Oriented Development with C#;李维(著)

Beijing Huaxin Electronic Publishing Co., Ltd.

Publishing House of Electronics Industry

电子工业出版社·北京

Bo wen shi dian,Pood xi lie, Bei jing, 2005

China, People's Republic, China

Di 1 ban, Beijing, 2005

Bookmarks: p0-1 (p1): 第0章 导读
p0-2 (p1): 目录
p0-3 (p7): 第1章 一个简单的想法
p0-4 (p13): 1.1 找寻问题的本质
p0-5 (p15): 1.2 搜寻解决方法
p0-6 (p15): 1.2.1 面向对象开发方法
p0-7 (p16): 1.2.2 测试驱动开发（TDD-Test-Driven Development）
p0-8 (p16): 1.2.3 结合面向对象分析／面向对象设计和XP/TDD
p0-9 (p17): 1.3 结论
p0-10 (p19): 第2章 分析和设计架构的思考
p0-11 (p19): 2.1 从自然的场景开始构思
p0-12 (p22): 2.2.1 需求捕获
p0-13 (p22): 2.2 PFM系统的设计
p0-14 (p24): 2.2.2 使用需求分析
p0-15 (p27): 2.2.3 产品设计
p0-16 (p34): 2.3 类架构的思考
p0-17 (p35): 2.4 建立开发环境
p0-18 (p36): 2.4.1 建立版本控制项目
p0-19 (p43): 2.5 结论
p0-20 (p45): 第3章 TDD和NUnit框架
p0-21 (p45): 3.1 取得NUnit For.NET
p0-22 (p46): 3.2 测试驱动开发模型
p0-23 (p47): 3.3 使用NUnit框架
p0-24 (p48): 3.3.1 范例场景
p0-25 (p49): 3.3.2 在C＃项目中使用NUnit
p0-26 (p50): 3.3.3 使用NUnit框架建立测试用例
p0-27 (p62): 3.3.4 NUnit框架提供测试服务的函数
p0-28 (p63): 3.3.5 使用测试包（Test Suite）
p0-29 (p68): 3.3.6 测试种类（Test Category）
p0-30 (p74): 3.4 结论
p0-31 (p77): 第4章 执行引擎和XML驱动设计
p0-32 (p78): 4.1 设计架构的思考
p0-33 (p83): 4.2 设定本章开发项目
p0-34 (p87): 4.3 封装配置信息类设计
p0-35 (p88): 4.3.1 TPFMConfig类的设计
p0-36 (p91): 4.3.2 TPFMConfigManager类的设计
p0-37 (p93): 4.3.3 TPFMSchedule类设计
p0-38 (p94): 4.3.4 TPFMScheduleManager类设计
p0-39 (p96): 4.4 从面向对象分析／设计转换到XP/TDD
p0-40 (p97): 4.4.1 TPFMConfigManager类实现
p0-41 (p101): 4.4.2 TPFMScheduleManager类实现
p0-42 (p104): 4.4.3 建立测试用例测试设计和实现的类
p0-43 (p111): 4.5 观察到父类的迹象
p0-44 (p114): 4.5.1 设计TPFMManager
p0-45 (p119): 4.5.2 使用TDD测试TPFMManager
p0-46 (p122): 4.6 改善和重构TPFMManager类
p0-47 (p131): 4.7 使用Together检查程序代码质量
p0-48 (p140): 4.8 类使用的设计模式
p0-49 (p142): 4.9 我们学到了什么
p0-50 (p143): 4.10 开发周期管理
p0-51 (p146): 4.11 另外一种开发配置
p0-52 (p148): 4.12 结论
p0-53 (p151): 第5章 多元，弹性架构的设计和实现——Handlers
p0-54 (p152): 5.1 设计架构的思考
p0-55 (p159): 5.2 设定本章开发项目
p0-56 (p160): 5.3 处理器接口和处理器类的设计和实现
p0-57 (p163): 5.4 处理器类派生类设计和实现
p0-58 (p164): 5.4.1 文件处理器类-TPFMFileHandler
p0-59 (p167): 5.4.2 压缩和反压缩处理器类-TPFMZipHandler
p0-60 (p175): 5.4.3 加密和解密处理器类
p0-61 (p181): 5.4.4 目录处理器类
p0-62 (p184): 5.4.5 一切都很好，除了
p0-63 (p186): 5.5 处理器工厂类设计和实现
p0-64 (p186): 5.5.1 处理器Factory类
p0-65 (p189): 5.5.2 测试处理器Factory类
p0-66 (p191): 5.5.3 进一步完善试处理器Factory类
p0-67 (p194): 5.5.4 测试处理器Factory类
p0-68 (p195): 5.5.5 为每一个处理器类建立独立的工厂类
p0-69 (p198): 5.5.6 测试处理器Factory类
p0-70 (p198): 5.6 对程序代码进行稽核和度量的工作
p0-71 (p198): 5.6.1 程序代码稽核
p0-72 (p199): 5.6.2 程序代码度量
p0-73 (p201): 5.7 Check In本章的源程序
p0-74 (p202): 5.8 处理器类和处理器工厂类的完善
p0-75 (p204): 5.9 结论
p0-76 (p207): 第6章 搜寻处理目标的设计和实现——Finders
p0-77 (p207): 6.1 搜寻处理目标类的思考和设计
p0-78 (p210): 6.2 设定本章开发项目
p0-79 (p212): 6.3 通用搜寻类-TFinder
p0-80 (p213): 6.4 目标文件搜寻类-TFileFinder
p0-81 (p218): 6.5 使用Factory设计模式-TFinderFactory
p0-82 (p219): 6.6 封装处理目标类-TCandidate
p0-83 (p221): 6.7 使用TDD测试类设计和实现
p0-84 (p225): 6.8.1 TFinder和TFileFinder类的改善
p0-85 (p225): 6.8 程序代码风格的讨论
p0-86 (p234): 6.9 结论
p0-87 (p237): 第7章 封装处理目标
p0-88 (p240): 7.1 设定本章开发环境
p0-89 (p240): 7.2 TCandidateFactory类
p0-90 (p242): 7.3 修改TCandidate类
p0-91 (p244): 7.4 修改客户端程序代码
p0-92 (p246): 7.5 重新使用TDD测试修改后的TCandidate类
p0-93 (p251): 7.6 结论
p0-94 (p255): 第8章 谁执行串联和集成的工作——Coordinator和Task
p0-95 (p256): 8.1 设计架构的思考
p0-96 (p259): 8.1.1 类架构设计
p0-97 (p262): 8.1.2 类互动
p0-98 (p263): 8.2 建立本章开发项目
p0-99 (p265): 8.3 类的设计和实现
p0-100 (p265): 8.3.1 使用Fa？ade设计模式
p0-101 (p268): 8.3.2 不光是提供Fa？ade功能
p0-102 (p268): 8.4 工作分派类TPFMTaskDispatcher
p0-103 (p269): 8.4.1 TPFMTaskDispatcher类的设计和实现
p0-104 (p272): 8.4.2 修改TPFMCoordinator使用TPFMTaskDispatcher类
p0-105 (p272): 8.4.3 修改TPFMManager类
p0-106 (p275): 8.5 以工作指派思想设计PFM需要执行的工作-TPFMTask
p0-107 (p275): 8.5.1 采用接口设计
p0-108 (p277): 8.5.2 工作类设计
p0-109 (p279): 8.5.3 TPFMTask工作类的实现
p0-110 (p281): 8.5.4 TScheduledTask类的设计和实现
p0-111 (p282): 8.5.5 TSpecifiedTask类的设计和实现
p0-112 (p284): 8.5.6 完成TPFMTaskDispatcher类
p0-113 (p285): 8.6 使用TDD进行测试
p0-114 (p290): 8.7 TPFMTask的工厂类
p0-115 (p292): 8.7.1 使用TDD测试TPFMTaskFactory
p0-116 (p293): 8.8 改善TPFMTaskDispatcher类
p0-117 (p295): 8.8.1 为TPFMTaskDispatcher加入对象池机制
p0-118 (p304): 8.8.2 修改TPFMTaskDispatcher类相关的方法
p0-119 (p305): 8.8.3 测试用例可以帮助我们进行所有的测试吗
p0-120 (p312): 8.9 程序代码稽核和程序代码度量
p0-121 (p313): 8.9.2 程序代码度量
p0-122 (p313): 8.9.1 程序代码稽核
p0-123 (p319): 8.10 Check In本章源程序
p0-124 (p320): 8.11 结论
p0-125 (p323): 第9章 如何持久储存——数据库处理器和Adapter
p0-126 (p323): 9.1 设计架构的思考
p0-127 (p326): 9.2 准备本章范例项目
p0-128 (p328): 9.3 TPFMDBAdapter类
p0-129 (p329): 9.4 TPFMDBBKAdapter类
p0-130 (p338): 9.5 修改TPFMDBHandler类
p0-131 (p339): 9.6 使用TDD测试数据库处理器类
p0-132 (p343): 9.7.1 程序代码稽核
p0-133 (p343): 9.7 程序代码稽核和程序代码度量
p0-134 (p345): 9.7.2 程序代码度量
p0-135 (p346): 9.8 结论
p0-136 (p349): 第10章 PFM系统和Assembly的设计
p0-137 (p349): 10.1 封装架构的思考
p0-138 (p350): 10.1.1 如何重新组织C＃类文件
p0-139 (p356): 10.2 准备本章范例项目
p0-140 (p357): 10.3 从最简单的地方开始-PFMSystemExceptions包
p0-141 (p358): 10.4 开发PFMSystemGlobals包
p0-142 (p359): 10.5 开发PFMSystemConfigurations包
p0-143 (p361): 10.6 开发PFMSystemCandidate包
p0-144 (p362): 10.7 开发Finders Assembly
p0-145 (p364): 10.8 开发处理器Assembly
p0-146 (p365): 10.9 开发PFM系统核心Assembly
p0-147 (p367): 10.10 如何确定Assembly能够正确工作
p0-148 (p373): 10.11 结论
p0-149 (p375): 第11章 让我们完工吧，OO和RAD
p0-150 (p375): 11.1 准备本章的开发环境
p0-151 (p377): 11.2 如何撰写常驻在Windows工具栏上的．NET程序
p0-152 (p379): 11.2.1 自定义ApplicationContext对象
p0-153 (p383): 11.2.2 修改C＃Windows Form主程序
p0-154 (p384): 11.3 如何设定系统时钟触发PFM系统的服务
p0-155 (p385): 11.4 集成PFM主程序和PFM类
p0-156 (p387): 11.5 Ready，Set，Go
p0-157 (p388): 11.6 测试PFM主程序
p0-158 (p390): 11.7 让PFM主程序更具响应性
p0-159 (p390): 11.7.1 更准确的显示时间
p0-160 (p391): 11.7.2 PFM系统工作时改变程序显示的图像
p0-161 (p392): 11.7.3 加入执行指定工作的服务
p0-162 (p394): 11.8 保存PFM系统主程序
p0-163 (p394): 11.9 结论
p0-164 (p397): 第12章 回到RAD，图形用户界面和组件
p0-165 (p398): 12.1 PFM公用程序设计思考
p0-166 (p399): 12.2 准备本章开发环境
p0-167 (p402): 12.3 PFM公用主程序
p0-168 (p403): 12.3.1 PFM公用程序定义程序单元
p0-169 (p404): 12.3.2 PFM公用主程序单元
p0-170 (p411): 12.3.3 PFM公用程序辅助类
p0-171 (p415): 12.4 执行PFM公用程序
p0-172 (p420): 12.5 保存本章开发结果
p0-173 (p420): 12.6 结论
p0-174 (p423): 第13章 撰写高效率的．NET应用程序
p0-175 (p423): 13.1 影响．NET执行效率的因素
p0-176 (p424): 13.1.1 虚拟堆栈机器
p0-177 (p426): 13.1.2 即时编译器（JIT）
p0-178 (p428): 13.1.3 最优化机器编译器
p0-179 (p430): 13.1.4 正确使用．NET机制和Framework
p0-180 (p433): 13.2 撰写高效率．NET应用程序
p0-181 (p434): 13.2.1 和垃圾回收器（Garbage Collection）协作
p0-182 (p438): 13.2.2 更好地使用Collection类
p0-183 (p441): 13.2.3 了解引用对象和值对象的使用
p0-184 (p446): 13.2.4 Boxing/Unboxing
p0-185 (p449): 13.2.5 字符串处理的陷阱
p0-186 (p450): 13.2.6 小心使用Reflection
p0-187 (p451): 13.2.7 使用效率监督工具
p0-188 (p452): 13.3 一些通用的建议
p0-189 (p455): 13.4 C＃和设计模式的执行效率
p0-190 (p455): 13.4.1 Command设计模式
p0-191 (p459): 13.4.2 FlyWeight设计模式
p0-192 (p463): 13.5 结论
p0-193 (p465): 第14章 更多的设计和实现，您能继续吗

related_files:
filepath:_11488452.zip — md5:346bc07296b06d4250cbcbcf6ae2bd95 — filesize:100275330
filepath:_11488452.zip — md5:bd3aac7ce4edba541a4e200c49e7d19f — filesize:100455750
filepath:11488452.zip — md5:2768a9b5ed6a3f25bd5e0c79886c06d7 — filesize:100315603
filepath:11488452.rar — md5:f6ba56b46104584f46821904934fb79f — filesize:100665028

topic: 软件工具；程序设计；C语言

Type: 当代图书

Bookmarks:
1. (p1) 第O章 导读
2. (p7) 第1章 一个简单的想法
2.1. (p13) 1.1找寻问题的本质
2.2. (p15) 1.2搜寻解决方法
2.3. (p17) 1.3结论
3. (p19) 第2章 分析和设计架构的思考
3.1. (p19) 2.1从自然的场景开始构思
3.2. (p22) 2.2PFM系统的设计
3.3. (p34) 2.3类架构的思考
3.4. (p35) 2.4建立开发环境
3.5. (p43) 2.5结论
4. (p45) 第3章 TDD和NUnit框架
4.1. (p45) 3.1取得NUnit For.NET
4.2. (p46) 3.2测试驱动开发模型
4.3. (p47) 3.3使用NUnit框架
4.4. (p74) 3.4结论
5. (p77) 第4章 执行引擎和XML驱动设计
5.1. (p78) 4.1设计架构的思考
5.2. (p83) 4.2设定本章开发项目
5.3. (p87) 4.3封装配置信息类设计
5.4. (p96) 4.4从面向对象分析/设计转换到XP/TDD
5.5. (p111) 4.5观察到父类的迹象
5.6. (p122) 4.6改善和重构TPFMManager类
5.7. (p131) 4.7使用Together检查程序代码质量
5.8. (p140) 4.8类使用的设计模式
5.9. (p142) 4.9我们学到了什么
5.10. (p143) 4.10开发周期管理
5.11. (p146) 4.11另外一种开发配置
5.12. (p148) 4.12结论
6. (p151) 第5章 多元，弹性架构的设计和实现——Handlers
6.1. (p152) 5.1设计架构的思考
6.2. (p159) 5.2设定本章开发项目
6.3. (p160) 5.3处理器接口和处理器类的设计和实现
6.4. (p163) 5.4处理器类派生类设计和实现
6.5. (p186) 5.5处理器工厂类设计和实现
6.6. (p198) 5.6对程序代码进行稽核和度量的工作
6.7. (p201) 5.7 Check In本章的源程序
6.8. (p202) 5.8处理器类和处理器工厂类的完善
6.9. (p204) 5.9结论
7. (p207) 第6章 搜寻处理目标的设计和实现——Finders
7.1. (p207) 6.1搜寻处理目标类的思考和设计
7.2. (p210) 6.2设定本章开发项目
7.3. (p212) 6.3通用搜寻类-TFinder
7.4. (p213) 6.4目标文件搜寻类.TFileFinder
7.5. (p218) 6.5使用Factory设计模式.TFinderFactory
7.6. (p219) 6.6封装处理目标类.TCandidate
7.7. (p221) 6.7使用TDD测试类设计和实现
7.8. (p225) 6.8程序代码风格的讨论
7.9. (p234) 6.9结论
8. (p237) 第7章 封装处理目标
8.1. (p240) 7.1设定本章开发环境
8.2. (p240) 7.2 TCandidateFactory类
8.3. (p242) 7.3修改TCandidate类
8.4. (p244) 7.4修改客户端程序代码
8.5. (p246) 7.5重新使用TDD测试修改后的TCandidate类
8.6. (p251) 7.6结论
9. (p255) 第8章 谁执行串联和集成的工作——Coordinator和Task
9.1. (p256) 8.1设计架构的思考
9.2. (p263) 8.2建立本章开发项目
9.3. (p265) 8.3类的设计和实现
9.4. (p268) 8.4工作分派类TPFMTaskDispatcher
9.5. (p275) 8.5以工作指派思想设计PFM需要执行的工作.TPFMTask
9.6. (p285) 8.6使用TDD进行测试
9.7. (p290) 8.7 TPFMTask的工厂类
9.8. (p293) 8.8改善TPFMTaskDispatcher类
9.9. (p312) 8.9程序代码稽核和程序代码度量
9.10. (p319) 8.10 Check In本章源程序
9.11. (p320) 8.11结论
10. (p323) 第9章 如何持久储存——数据库处理器和Adapter
10.1. (p323) 9.1设计架构的思考
10.2. (p326) 9.2准备本章范例项目
10.3. (p328) 9.3 TPFMDBAdapter类
10.4. (p329) 9.4 TPFMDBBKAdapter类
10.5. (p338) 9.5修改TPFMDBHandler类
10.6. (p339) 9.6使用TDD测试数据库处理器类
10.7. (p343) 9.7程序代码稽核和程序代码度量
10.8. (p346) 9.8结论
11. (p349) 第10章 PFM系统和Assembly的设计
12. (p375) 第11章 让我们完工吧，OO和RAD
13. (p397) 第12章 回到RAD，图形用户界面和组件
14. (p423) 第13章 撰写高效率的.NET应用程序
15. (p465) 第14章 更多的设计和实现，您能继续吗

theme: 软件工具；程序设计；C语言

Type: modern

Ben shu zhu yao jie shao le li yong zhu liu kai fa fang fa xue he ji shu ji qiao jin xing mian xiang dui xiang kai fa de yuan ze yu shi jian, Tong guo wan zheng pou xi yi ge shi ji ying yong cheng xu de she ji, Kai fa yu shi xian, Chan shu le OOD, OOP, TDD, UT deng kai fa fang fa xue yu zui jia shi jian de ying yong yu ji shu ji qiao

本书主要介绍了利用主流开发方法学和技术技巧进行面向对象开发的原则与实践, 通过完整剖析一个实际应用程序的设计, 开发与实现, 阐述了OOD, OOP, TDD, UT等开发方法学与最佳实践的应用与技术技巧

2024-06-13