注册 | 登录读书好,好读书,读好书!
读书网-DuShu.com
当前位置: 首页出版图书科学技术计算机/网络软件与程序设计.NETVisual Basic互操作高级编程:从COM和VB6升级到.NET

Visual Basic互操作高级编程:从COM和VB6升级到.NET

Visual Basic互操作高级编程:从COM和VB6升级到.NET

定 价:¥42.00

作 者: Billy Hollis,Rockford Lhotka著;康博译;康博译
出版社: 清华大学出版社
丛编项: 清华·乐思 NET和Oracle编程经典系列
标 签: VB

购买这本书可以去


ISBN: 9787302057468 出版时间: 2002-08-01 包装: 精装
开本: 26cm 页数: 376 字数:  

内容简介

  在.NET迅速崛起的时代,我们并不能完全抛弃COM时代使用VB6开发的各种应用程序,因此实现VisualBasic.NET和VB6之间的互操作就显得十分必要了。本书由浅入深介绍了互操作涉及的各种问题,详细讲述了.NET与COM互操作的各种机制,并给出了一些实际的应用示例。在示范了具体的操作步骤后,本书还深入到系统内部讲述了互操作的实现细节,并对系统底层编程提出了相应的建议。本书适用于那些想详细深入地掌握VB6与VisualBasic.NET互操作的开发人员,它对于把VB6系统升级为VisualBasic.NET提供了大量实用的操作方法。

作者简介

暂缺《Visual Basic互操作高级编程:从COM和VB6升级到.NET》作者简介

图书目录

第1章  互操作功能的重要性                  
 1. 1  Visual Basic . NET概述                  
 1. 2  迁移方案                  
 1. 2. 1 VB6和Visual Basic . NET的不兼容之处                  
 1. 2. 2  迁移到Visual Basic . NET的好方案                  
 1. 2. 3  坏的迁移情况                  
 1. 2. 4  不能迁移的情况                  
 1. 2. 5  互操作性的含义                  
 1. 3  设计互操作方案                  
 1. 3. 1  Web服务                  
 1. 3. 2  智能型客户端                  
 1. 3. 3  新的ASP. NET前端                  
 1. 3. 4  扩充原有的组件                  
 1. 3. 5  分布式数据处理                  
 1. 4  互操作应用的主要范围                  
 1. 4. 1  在. NET中调用COM组件                  
 1. 4. 2  在COM中调用. NET组件                  
 1. 4. 3  在新旧程序间共享数据访问                  
 1. 4. 4  共享配置信息                  
 1. 4. 5  使用静态入口点调用非COM的DLL                  
 1. 5  小结                  
 第2章  在. NET中使用COM组件                  
 2. 1  创建COM组件                  
 2. 1. 1  构建COM组件                  
 2. 1. 2 二进制兼容性                  
 2. 2  导入COM组件                  
 2. 2. 1  在设计阶段导入COM组件                  
 2. 2. 2  动态导入                  
 2. 3  使用COM组件                  
 2. 3. 1  早期绑定                  
 2. 3. 2  后期绑定                  
 2. 3. 3  对象的生存期                  
 2. 3. 4  多重接口                  
 2. 3. 5  继承性                  
 2. 3. 6  在.NET中检查COM组件                  
 2. 4  小结                  
 第3章  在COM中使用, NET程序集                  
 3. 1  创建.NET程序集                  
 3. 1. 1  创建. NET程序集概述                  
 3. 1. 2 对互操作进行设置                  
 3. 1. 3  使用ComClass()属性                  
 3. 1. 4  手工提供类                  
 3. 2  在COM中注册. NET程序集                  
 3. 2. 1  使用Visual Studio .NET                  
 3. 2. 2  使用命令行实用程序                  
 3. 3  在COM和Windows中使用NET对象                  
 3. 3. 1  早期绑定                  
 3. 3. 2  后期绑定                  
 3. 3. 3  处理销定的文件                  
 3. 3. 4  对象生存期                  
 3. 3. 5  多重接口和默认接口                  
 3. 3. 6  在COM中检查. NET程序集                  
 3. 4  小结                  
 第4章  从. NET调用MTS和COM+中的COM组件                  
 4. 1  使用COM+组件                  
 4. 1. 1  创建COM+组件                  
 4. 1. 2  在Visual Basic . NET中调用COM+组件                  
 4. 1. 3  排队组件                  
 4. 2  传输数据                  
 4. 2. 1  使用AD0中的Recordset对象                  
 4. 2. 2  使用变量数组                  
 4. 2. 3  使用XML文档                  
 4. 3  在VB6中调用COM+中的.NET组件                  
 4. 3. 1  在. NET中创建CoM+组件                  
 4. 3. 2  使类可用于COM客户程序                  
 4. 4  小结                  
 第5章  COM+中的Visual Basic. NET和COM                  
 5. 1  COM+和VB6                  
 5. 1. 1  为COM+创建ActiveXDLL                  
 5. 1. 2  在COM+中注册DLL                  
 5. 1. 3  创建VB6测试程序                  
 5. 2  COM+和Visual Basic . NET                  
 5. 2. 1  在COM+中注册DLL                  
 5. 2. 2  创建Visual Basic . NET测试程序                  
 5. 3  从COM+中的Visual Basic . NET中调用VB6组件                  
 5. 4  从COM+内的VB6中调用Visual Basic . NET组件                  
 5. 5  小结                  
 第6章  定制编组                  
 6. 1  四种不同的编组方法                  
 6. 1. 1  第一种编组方法:使用Tlbimp. exe                  
 6. 1. 2  第二种编组类型(简单数据类型编组):将属性添加到使用标推类型的接口中                  
 6. 1. 3  第三种编组类型:对COM和. NET之间传递的自定义数据结构进行编组                  
 6. 1. 4  第四种编组类型:实现ICustomMarshaler接口                  
 6. 2  性能问题                  
 6. 3  第二种编组类型                  
 6. 3. 1  Ildasm                  
 6. 3. 2  Ilasm                  
 6. 3. 3  使用带有第二种编组类型的Ildasm或者Ilasm                  
 6. 4  第三种编组类型                  
 6. 5  第四种编组类型                  
 6. 6  托管代码到非托管代码                  
 6. 7  小结                  
 第7章  线程问题                  
 7. 1  线程的基础知识                  
 7. 1. 1  线程的复杂性                  
 7. 1. 2  使用单线程与多线程                  
 7. 1. 3  VB6中的线程                  
 7. 1. 4  Visual Basic . NET中的线程                  
 7. 2  线程之间的互操作                  
 7. 2. 1  在. NET中调用COM                  
 7. 2. 2  在COM中调用. NET                  
 7. 3  小结                  
 第8章  DCOM. 远程处理和Web服务                  
 8. 1  XML Web服务                  
 8. 2  . NET远程处理                  
 8. 3  DCOM                  
 8. 4 XML Web服务和互操作                  
 8. 4. 1  从. NET中调用COM                  
 8. 4. 2  从COM中调用. NET                  
 8. 5  . NET远程处理和互操作                  
 8. 5. 1  从. NET中调用CoM                  
 8. 5. 2  从COM中调用. NET                  
 8. 6  小结                  
 第9章  共享配置信息                  
 9. 1  专用的INI文件                  
 9. 1. 1  INI文件的结构                  
 9. 1. 2  访问VB6中的INI文件                  
 9. 1. 3  访问Visual Basic . NET中的凹文件                  
 9. 2  使用Windows注册表存储配置设置                  
 9. 3  基于XML的配置文件                  
 9. 3. 1  访问带有. NET Framework类的XML配置信息                  
 9. 3. 2  使用Visual Basic . NET中的System. XML访问设置信息                  
 9. 3. 3  使用VB6中的MSXML访问设置                  
 9. 4  并行性问题                  
 9. 5  小结                  
 第10章  . NET中的平面文件访问                  
 10. 1  对于平面文件的随机访问                  
 10. 1. 1  VB6中的随机访问                  
 10. 1. 2  Visual Basic . NET中的随机访问                  
 10. 2  平面文件的二进制访问                  
 10. 2. 1  VB6中的二进制访问                  
 10. 2. 2  Visual Basic . NET中的二进制访问                  
 10. 3  顺序的文件访问                  
 10. 3. 1  VB6中的顺序访问                  
 10. 3. 2  Visual Basic . NET中的顺序访问                  
 10. 4  作为Visual Basic . NET中替代方案的流                  
 10. 4. 1  使用流技术的顺序访问                  
 10. 4. 2  使用流技术的二进制访问                  
 10. 5  小结                  
 第11章  在. NET中使用ADO                  
 11. 1  AD0和ADO . NET之间的比较                  
 11. 1. 1  AD0优点和缺点                  
 11. 1. 2  在. NET中何时仍然需要ADO                  
 11. 2  在.NET中使用ADO                  
 11. 2. 1  Visual Basic . NET中的ADO代码                  
 11. 2. 2  数据绑定限制                  
 11. 2. 3  将一些AD0属性设置为字符串而引发的问题                  
 11. 2. 4  将ADORecordset转换为ADO. NET DataSet                  
 11. 3  DA0和RD0的意义                  
 11. 4  小结                  
 第12章  在. NET中调用APl或静态DLL函数                  
 12. 1  . NET对使用带有静态入口点的DLL的需求在减少                  
 12. 1. 1  对访问Win此wsAPI的需求减少                  
 12. 1. 2  较旧代码的退休                  
 12. 2  平台调用服务                  
 12. 2. 1  声明APl                  
 12. 2. 2  调用API函数                  
 12. 2. 3  给函数指定别名                  
 12. 2. 4  将结构作为参数传递                  
 12. 2. 5  数据编组问题                  
 12. 3  更多的控制                  
 12. 3. 1  控制数据编组                  
 12. 3. 2  使用DLLImport而不是Declare                  
 12. 4  性能因素                  
 12. 5  小结                  
 第13章  . NET中ActiveX控件的互操作性                  
 13. 1  何时在.NET中使用ActiveX控件                  
 13. 2  Windows Forms控件和ActiveX控件之间的差异                  
 13. 3  在. NET中驻留ActiveX控件                  
 13. 3. 1  示例--Windows Media Player控件                  
 13. 3. 2  关于示例的注意事项                  
 13. 3. 3  从Properties列表中移出的Custom属性                  
 13. 3. 4  使用Aximp. exe创建包装器                  
 13. 3. 5  导入VB6 UserControls                  
 13. 3. 6  不能导入的控件                  
 13. 3. 7  安全性                  
 13. 4  VB6中的. NET Windows Forms控件                  
 13. 5  小结                  
 第14章  VB6代码迁移的准备工作                  
 14. 1  停止使用默认的属性和方法                  
 14. 2  避免数组的非零下界                  
 14. 3  让所有的参数显式地传值或引用(ByRef或ByVal)                  
 14. 4  将默认值放在所有可选的参数上                  
 14. 5  在独立的代码行上声明所有变量                  
 14. 6  注意声明变量的位置                  
 14. 7  避免UDT中的固定长度字符串                  
 14. 8  清除已作废的关键字                  
 14. 9  删除隐式对象实例化                  
 14. 10  停止隐式加载窗体                  
 14. 11  将数据绑定转换到ADO                  
 14. 12  尽可能使用固有的常量                  
 14. 13  停止编写DHTML页面和WebClass                  
 14. 14  包装API调用                  
 14. 15  从UI中得到逻辑并放入组件和类中                  
 14. 16 避免后期绑定                  
 14. 17  小结                  

本目录推荐