求教大神 oracle+arcgis 有报酬！！！！

哪位大神可以教一下arcgis+oracle数据库的应用，因为要做毕业设计，指导完会做出相应的感谢！！！！！回复我qq号

oracel +arcgis?

oracle可和arcsde一起作为空间数据库解决方案。

基于ArcGIS10.0和Oracle10g的空间数据管理平台（C#开发）ArcGIS相关知识补充学习【转】


  
其实开发一个项目，难点不在于语言方面，不管哪一种语言都不是你实现一个项目的阻力，其实真正能不能完成一个项目，要看能不能完整而详细的理解项目的需
求，然后理解需求的基础又是对行业相关知识的把握，只有弄清楚了行业知识以及相关的概念并且能够深入理解，才能轻松加愉快的完成项目，不然的话只有每天在
无情的加班和代码面前无能为力。就针对我讲解的这个项目的开发，对于当时的我来说却是存在很多新的概念，而且第一次看资料还不一定能够看懂，只有不停的查
阅更多相关资料并深入理解才能够把握项目的功能需求。下面就针对自己在学习相关概念和知识时收集到的一些ArcGIS资料整理如下，这些资料都是从网上收
集来的，所以感谢那些无私的在互联网上提供各种学习资料的人，当然我也乐于将自己的所学和所得与互联网上的同行们分享之。
    ArcGIS
Server是一个发布企业级GIS应用程序的综合平台，提供了创建和配置GIS应用程序和服务的框架，可以满足各种客户端的各种需求，这是对
ArcGIS Server一个抽象的描述，那么ArcGIS Server在GIS应用中具体扮演什么样的角色呢？
     使用过ArcGIS
桌面应用软件的人知道，在桌面环境中存在各种GIS工具可以供使用，如展现GIS数据可以用ArcMap、ArcGlobe，根据位置寻址可以使用
address
locator，对数据进行分析操作可使用ArcToolbox的Geoprocessing工具，这些包含了不同级别的GIS功能，从底层来看，都是通
过ArcObjects来实现这些的。
 
     站在ArcGIS
Server的角度上，我们不再考虑要处理的数据是ArcMap的mxd文档、ArcGlobe的3dd文档、还是address
locators等，相应地，我们用服务的概念来对它们进行描述，这些服务可以是map services、globe
services、geocode services，GIS资源依托这些服务存在，当需要在GIS
Server上共享一个地图时，就使用该地图的mxd来定义一个Map Service。可以看出，ArcGIS
Server的目的就是宿主各种服务，并为客户端应用提供这些服务资源，另外，ArcGIS
 Server提供了一个管理程序来对服务进行控制与管理。
ArcGIS Server体系结构可以用下图来描述：
 
 
     （1）GIS Server
 
      宿主各种GIS资源，例如maps、globes、address locators，并将它们封装为服务提供给客户端应用。
      GIS Server本身包括两部分：Server Ojbect Manager(SOM)和Server Object
Containers(SOCs)。通过命名可以看出，是一个SOM和一个或多个SOC，客户端发送请求到SOM，SOM将分配的资源提供给客户端，通过
 SOM对SOC进行调度与管理。
 
     （2）Web Server

     Web Server包含Web应用的部署，以及Web服务，它们均使用GIS Server上的服务资源。
 
     （3）Clients
 
     这里所说的客户端是多样化的，可以是Web客户端、Mobile移动设备、通过HTTP连接到ArcGIS Server Internet服务或通过LAN/WAN连接到ArcGIS Server Local Services的ArcGIS桌面应用。
 
     （4）Data Server
 
     包含GIS Server上所发布服务的GIS资源，可以是mxd文档、geodatabase、toolbox等。
 
     （5）Manager and ArcCatalog administrators
 
     两者都可以用来将GIS资源作为服务发布，并进行管理，不同的是一个是在Web页面上管理，另一个在桌面Catalog上，在图上可以看出，它们所针对的层次有所不一样。
 
     （6）ArcGIS Desktop content authors
 
     各种GIS资源需要使用各种ArcGIS Desktop软件来定制，如果需要为地图服务生成缓存，可以用ArcCatalog来创建cache。
ArcGIS Engine 是一组跨平台的嵌入式 ArcObjects ，它是 ArcGIS 软件产品的底层组件，用来构建定制的 GIS
和桌面制图应用程序，或是向原有的应用程序增加新的功能。 ArcGIS Engine 应用程序可以是简单的地图浏览器，也可以是定制的 GIS
编辑和分析程序。通过 ArcGIS Engine 构建的应用，既可以以地图显示为中心，也可以不是，这一点非常重要。这一特性使 ArcGIS
Engine 特别适合于构建非 GIS 为中心的应用。
 ○ 设置或自定义ArcGIS应用程序，例如ArcMap；
 ○ 扩展ArcGIS，例如开发自己的扩展工具包（Toolbox），或者增加新的数据模型；
 ○ 应用ArcEngine开发胖客户端应用程序，例如在其他程序中嵌入GIS功能；
 ○ 应用ArcGIS Server创建Web程序或者Web服务。
    
有关AO和ArcGIS系列的关系，我们在各类文档中已经见得很多了，这里就不说了。有一点要强调，就是所有产品的核心是AO，而ArcGIS
Engine或者ArcGIS
server与Desktop不同之处在于前者提供了面向胖客户端和服务器端的中等粒度的控件，而后者的开发则无法使用这些控件。对于应用ArcGIS开
发过的读者可以发现，即使不安装ArcEngine，ArcEngine下的很多控件，例如Map、3D显示的控件，也是在系统中存在的，可以推测，在
ArcGIS 9.x中，Desktop应该也使用了这些控件（需要证实！）。
 
 ○ 自定义ArcMap、ArcCatalog的布局和界面，包括增加自定义的按钮，指定相应的宏；
 ○ 使用VBA创建解决方案；
 ○ 创建ArcGIS扩展；
 ○ 创建独立的应用程序（后面单独说明）。
 
(1)自定义ArcGIS Desktop
    理解自定义ArcGIS
Desktop和理解Office下的Word的自定义类似。以ArcMap为例，对于一个Map文档（mxd），包括下面几个部分：使用的数据（即该地
图使用了那些数据）；地图的布局；当前程序的界面布局（自定义）；VBA工程。对于模版（template），有Normal
Template和地图Template的区别，前者影响ArcMap程序本身，即所有打开文档都有应用Normal模版，后者只影响使用了该模版的地
图。因此，使用自定义的模版，是ArcGIS
Desktop开发的第一个层次，通过将需要的界面元素集合起来，并重新安排，即可组成一个符合客户需求的自定义程序，而集合一定的VBA代码，可以完成
的工作就非常多了。例如一个快递公司，可以把地图操作（缩放、移动、打印等）、网络分析相关的界面元素通过自定义工具，整合在一起，隐藏掉其他工具和界面
元素，就可以比较好的应用于实际工作。
(2)应用VBA
    
应用VBA开发解决方案有很多优势，例如不需要安装第三方开发工具、简单、易于使用，还有一点就是在不熟悉AO结构的前提下，使用VBA要比使用其他方式
更易上手。对于非专业程序员，使用VBA应该是ArcGIS Desktop开发的首选；对于专业开发者，通过VBA也是学习和熟悉AO很好的途径。
     VBA工程：VBA工程是ArcGIS中VBA程序和代码的载体，和地图模版（template）或者地图（mxd文件）一起保存。打开VBA编辑器后，有Normal和目前打开的文件2个VBA工程。对于一个VBA工程，由以下几类对象组成：
 ○ ArcMap对象
 ○ 过程模块
 ○ 窗体模块
 ○ 类模块
 ○ 引用（对Normal模版的引用）
    
对于大多数开发，首先是通过自定义界面，例如创建工具按钮，然后就可以在ArcMap对象中选择这个工具，创建其事件响应过程。例如我们自定义一个按
钮，UIButtonControl1，然后在ThisDocumnet代码窗口的对象选择列表框选择UIButtonControl1，在事件列表框选
择Click，创建UIButtonControl1_Click过程，在其中就可以书写该按钮单击后调用的代码。
通过窗体可以创建自定义对话框或者窗口，类模块则可以创建自己的对象。 编写ArcGIS
Desktop扩展编写ArcGIS扩展，可以完成以下任务（下图）：
 \
 
 ○ Command：即一个按钮、菜单，通过实现ICommand、ITool、IToolCommand接口来创建；
 ○ Edit Task：与ArcMap Editor协同工作的组件，需要实现IEditTask接口；
 ○ Table of Contents tab：类似左侧的数据和图层视图的小窗口，通过实现IContentsView接口来创建；
 ○ Class extension：自定义对象（feature），即有自己属性和规则的空间对象，例如红绿灯对象，电线，电闸等等，需要实现IClassExtension等接口。 copyright gispark.com
 
（3）应用程序的插件架构
    对于ArcGIS Desktop的开发，最关键的核心问题在于理解ArcGIS插件架构的运行机制，下面我们就对这个问题做一简单介绍。
    插件架构的核心在于应用程序定义插件遵循的接口，然后由自定义组件来实现这个接口。其中有几个关键点：
第一，主应用程序如何知道要加载插件
    对于ArcGIS是使用注册表，和MS Office类似，在注册表中建立一个“component
categories”的条目，而组件要被ArcGIS加载，就需要注册后，在这里增加添加一个条目。对于现在的大多数.net程序和前COM时代的C或
C++程序，则通过目录来做到这点，通过遍历目录中的文件，然后通过反射机制（.net）来加载。而COM程序，如VB环境下，则可以通过
CreatObject来加载一个组件。
第二，插件的初始化
    
初始化包括2方面，一方面，主程序要创建一个变量，类型为插件所实现的接口，然后创建该插件，而同时，调用插件的初始化代码，例如Connect，传入需
要主程序要暴露给插件的引用（App）。对于COM程序或者.net，是通过事件来做到这一点。主程序触发初始化事件，该事件在插件的代码中实现，根据传
来的变量，初始化插件的运行环境。对于C或者C++这样的环境，可以通过函数指针和回调函数来实现这一点。插件的初始化过程，就是插件插件和主程序通讯桥
梁的过程，这个桥梁，对于ArcGIS，就是IApplication接口。
第三，插件和应用程序之间的通讯
    
其实上边已经差不多说清楚了，对于主应用程序，是通过创建插件对象，获得当前插件的实例，然后控制他，如果是插件是一个按钮，那么初始化插件的时候，创建
了按钮对象，并绑定按钮的click事件由插件的相应过程来处理。对于插件，则由于在初始化中通过初始化事件（例如OnCreat或者Connect这样
的事件）的参数得到了当前应用程序的Application等对象实例，因此就可以使用这些对象实例来操作应用程序。对于应用程序的一些状态变化，可以通
过定义事件，然后在插件代码中响应这些事件来完成。
 
第四，用户界面
    Microsoft
Office的COM加载宏的编写，需要通过调用Office的Commandbar等对象来创建用户界面元素，可以完全自定义。对于Photoshop
这样的程序，插件程序使用C或C++来完成，扩展的位置固定在几个确定的扩展点。ArcGIS个人觉得基本上处于二者之间。 本文来GIS公园
    开发ArcGIS扩展模块的步骤和方法：明白了ArcGIS的插件架构，下来的开发主要就是在熟悉AO的基础上，应用AO的功能开发具体的应用，或者扩展AO没有提供的功能。一个扩展模块开发的基本步骤如下：
（a）新建工程，添加AO的引用；
（b）实现需要的接口，添加具体的代码；
（c）编译为DLL，注册该COM组件，并在ArcGIS的omponent categories注册（也可以使用界面的自定义对话框浏览定位到具体的dll来注册）；
（d）测试和调试。
目前，ArcGIS Desktop扩展的开发环境包括COM兼容环境（例如VB或者VC），.net 1.1的VB.net或者C#。
（4）独立应用程序
    一个GIS应用程序，必须实现基本的地图功能，打开VB 6或者.net开发环境，可以看到随ArcGIS
Desktop安装的有Map，PageLayout，Toc，Toolbar等控件。而在Desktop下可以使用（有许可）的只有Map和
PageLayout控件。对于某些程序，也可以通过此类方法开发，但ESRI推荐在嵌入式或者胖客户端程序，使用ArcGIS Engine。
总结
熟悉了ArcGIS Desktop开发的基本思路以及ArcGIS Desktop的插件架构的基本思想，应用ArcGIS
Desktop开发就不再是复杂度很大的事情了。下来的主要工作就是熟悉AO，要熟悉AO，除了面向对象的知识外，GIS的很多原理和知识也是必要的，下
回再见。
 
     Geodatabase是什么呢？Geodatabase实际上可以看成是我们在系统中所处理和使用的所有空间数据的一个智能库。物理上，数据被存放在数据库管理系统（DBMS）中，其类型可以是各种各样的，包括：
Vector  Topology
Raster  Networks
Addresses  TINs
Relationships and Rules  CAD
Metadata  Tables
    
Geodatabase数据模型使现实世界的空间数据对象与其逻辑数据模型更为接近。在geodatabase中，我们定义的不再是传统GIS对空间数据
进行抽象后的“点”、“线”、“面”等简单空间要素，而是应用领域中熟悉的对象，如：杆塔、刀闸、电缆、道路、建筑、用地等。更重要的是
geodatabase使我们不需要编写任何程序代码即可实现数据对象主要的操作行为。大多数的操作行为都可以通过对象值域（Domain）、子类型
（Subtype）、规则等的定义以及ArcInfo提供的应用框架中丰富的其它功能来完成。对特殊应用中必须定义或扩展的空间对象，ArcInfo支持
工业标准的统一建模语言（UML）和CASE工具（如：Visio
 2000 Enterprise），通过CASE工具完成对数据对象的定义和扩展。
 
       ArcGIS Desktop是ArcGIS
family的桌面端软件产品，为GIS专业人士提供的信息制作和使用的工具。利用ArcGIS
Desktop，你可以实现任何从简单到复杂的GIS任务，包括制图，地理分析，数据编辑，数据管理，可视化和空间处理等。它可以作为三个独立的软件产品
购买，每个产品提供不同层次的功能水平：
•ArcView提供了复杂的制图、数据使用、分析，以及简单的数据编辑和空间处理工具。
•ArcEditor除了包括了ArcView中的所有功能之外，还包括了对Shapefile和geodatabase的高级编辑功能。
•ArcInfo是一个全功能的旗舰式GIS桌面产品。它扩展了ArcView和ArcEditor的高级空间处理功能，还包括传统的ArcInfo Workstation应用程序（Arc，ArcPlot，ArcEdit，AML等）。
        
ArcView，ArcEditor，和ArcInfo仅在功能水平上有所区别，其结构都是统一的，所以地图、数据、符号、地图图层、自定义的工具和接
口、报表和元数据等，都可以在这三个产品中共享和交换使用。使用者无须去学习几个不同的结构框架，本轻松入门亦是针对上述三种版本均适用。
不论是ArcView，ArcEditor还是ArcInfo，常用的应用程序都有ArcMap和ArcCatalog。ArcMap是ArcGIS
Desktop中一个主要的应用程序，具有基于地图的所有功能，包括地图制图、数据分析和编辑等。ArcMap提供两种类型的地图视图：数据视图和版面视
图。在数据视图中，可以对图层进行符号化、分析和编辑GIS数据集。在版面视图中，可以进行地图出图排版，添加地图元素，比如比例尺，图例，指北针等。
    ArcCatalog是地理数据的资源管理器，帮助你组织和管理你所有的GIS信息，比如地图，数据集，模型，元数据，服务等。它包括了下面的工具：
（1）浏览和查找地理信息。
（2）记录、查看和管理元数据。
（3）定义、输入和输出geodatabase结构和设计。
（4）在局域网和广域网上搜索和查找GIS数据。
（5）管理ArcGIS Server。
      
GIS使用者使用ArcCatalog来组织、管理和使用GIS数据，同时也使用标准化的元数据来描述数据。GIS数据库的管理员使用
ArcCatalog来定义和建立geodatabase。GIS服务器管理员则使用Arccatalog来管理GIS服务器框架。
1、概述
         ArcGIS Server——基于AO的对象服务器，由GIS Server和Application Developer
Framework（ADF）组成；GIS Server由Server Object Manager（SOM）和Server Object
Container（SOC）组成；ADF利用AO来构建运行于GIS Server之上的web应用和web服务主要安装ArcGIS Server
Object Manager&ArcGIS Server Object Container，先尝试在同一台机器上配置，再装在分布式系统上
 
2、基于.NET Framework的ArcGIS Server的组成
GIS Server——SOM & SOC
SOM——管理在唯一主机上的windows服务，用于管理分布在各个SOC上的服务对象；
SOC——可以装在多台机器上，是服务对象的宿主。每一台SOC机器可以产生多个Container processes，一个Container
 processes可以运行多个服务对象，Container processes 是由SOM来管理的。（每台SOC机器都需要一个授权文件）
Web Applications
Web Application Developer Framework——Runtime & Software Developer Kit
 
Runtime安装在Web Sever机器上，SDK安装在Web Application上
Mobile Application Developer Framework
 
3、ArcGIS Server系统架构：
GIS Server——存储GIS资源，为客户端应用提供服务，SOM和SOC
Web Server——向GIS Server 请求web应用和web服务
Clients——客户端应用（web browsers，mobile，desktop application等）；web
browsers可以连接到web server上的web application，桌面应用可以通过HTTP协议连接到web
server，也可以直接通过LAN或WAN直接连到Web server
Data Server——包含发布在GIS服务器上的资源（map document、address locators、Geodatabase、toolboxes等）
Manager and ArcCatalog administrators——ArcGIS Server管理器，用来管理和发布资源服务
ArcGIS Desktop content authors——创建GIS资源
 
4、ArcGIS Server配置
Web ADF Runtime必须装在Web Server 机器上，如果要采用它创建桌面应用，Web ADF Runtime 还应当装在运行这些application的所有机器上；
ArcGIS Desktop application 可以用来创建数据或管理GIS Server，但它只能装在可以通过本地网络连接GIS Server的windows机器上；
每一个SOM管理它自己的SOC集群；
SOCs可以装在一台或多台机器上，每一台装有SOC的机器需要添加到SOM的管理列表中去；
Web应用也可以用来管理GIS Server，web application 包含ArcGIS Server manager application，并且应当装在web server机器上
 
5、配置实例
ArcGIS Server 装在单机上：（ArcGIS Desktop可以装在同一机器上）
多个SOC（SOC不一定要和SOM在同一机器上）
单一Web Server机器（ArcGIS Desktop可以装在任一机器上）
 
6、Post Installation
配置GIS Server：创建GIS Server帐户，指定SOM帐户、密码，SOC帐户、密码（二者都可以是本地帐户或者域帐户，域帐户必须是已经存在的），装有SOM的机器上的SOM帐户和SOC帐户必须和其它SOC帐户是一样的；
SOM帐户权限：start container processes；
SOC帐户权限：写系统temp目录，运行container proceses；
创建2个新的用户组：agsusers和agsadmin，将不同的操作系统用户归于不同的用户组，也就授予了不同的访问GIS Server的权限。ArcGIS采用操作系统鉴定来设置不同帐户对GIS Server的管理或使用权限。
GIS Server授权：安装SOC的机器需要授权文件来运行container processes
 
Web application post install
后续设置：
重启电脑；
设置对GIS Server的帐户的访问权限（加入不同的组）；
连接到GIS Server；
将所有SOC机器添加到SOM管理列表中；
组织GIS数据，设置合适的路径使其对所有SOC机器可以引用（GIS Server上的服务数据源就是ArcGIS Desktop的数据源）；
为GIS Server添加服务，并向其它用户发布；
创建客户端应用或使用ArcGIS Desktop访问服务，一旦在GIS Server上发布了服务，就可以在web或desktop应用中去使用
 
7、ArcGIS Instances
概念：是一组web server、GIS
server和一系列服务和应用程序。默认开始只有一个叫做ArcGIS的Instance，可以添加自定义的，Instances可以共享同一个Web
 server甚至是相同的SOCs，但必须是不同的SOM。并且不同的Instance，其应用和服务也应该不同。
创建Instance：使用在ArcGIS安装目录下的DoNet"AddInstance.exe，访问web services的URL：http://<server name>/<instance name>/services
 
8、在windows workgroup环境下配置ArcGIS Server
-所有用户必须是本地用户，所有加进agsusers或agsadmin组的帐户也必须是本地用户；
-这些本地帐户必须在所有机器上使用相同的用户名和密码；
-更改本地安全默认设置如下：控制面板——管理工具——本地安全策略——本地策略——安全选项——网络访问：本地帐户的共享和安全模式（双击，修改为经典-本地用户以自己的身份验证）

  
由于在介绍通用数据管理模块功能的时候用到了许多通用的功能，例如word和excel与DataGridView控件的相互导入导出、写日志到数据库中
等等。为了后面每一篇文章都能清楚的知道每一个功能具体是怎么实现的，现在先统一把用到的所有公用功能统一介绍和实现。由于SqlHelper类，也就是
数据库的一些通用操作已经在登录模块中介绍，就不在重复介绍了。本篇将相介绍通用工具类CommonTools，由于代码中有比较详细的注释了，就不详细
解析具体代码的功能了。这个类实现的功能如下。
1.从DataGridView控件导出数据到Word文档

1. /// <summary>  
2. /// 从DataGridView控件导出数据到word文档  
3. /// </summary>  
4. /// <param name="dgv"></param>  
5. public static void ExportDataGridViewToWord(DataGridView dgv)  
6. {  
7.    //打开保存的文件名  
8.    SaveFileDialog sfile = new SaveFileDialog();  
9.    sfile.AddExtension = true;  
10.    sfile.DefaultExt = ".doc";  
11.    sfile.Filter = "(*.doc)|*.doc";  
12.    if (sfile.ShowDialog() == DialogResult.OK)  
13.    {  
14.        object path = sfile.FileName;  
15.        Object none = System.Reflection.Missing.Value;  
16.        Microsoft.Office.Interop.Word.Application wordApp = new Microsoft.Office.Interop.Word.Application();  
17.        Microsoft.Office.Interop.Word.Document document = wordApp.Documents.Add(ref none, ref none, ref none, ref none);  
18.        //建立表格  
19.        Microsoft.Office.Interop.Word.Table table = document.Tables.Add(document.Paragraphs.Last.Range, dgv.Rows.Count, dgv.Columns.Count, ref none, ref none);  
20.        try  
21.        {  
22.            //设置标题  
23.            for (int i = 0; i < dgv.Columns.Count; i++)  
24.            {  
25.                table.Cell(0, i + 1).Range.Text = dgv.Columns.HeaderText;  
26.            }  
27.            //填充数据  
28.            for (int i = 1; i < dgv.Rows.Count; i++)  
29.            {  
30.                for (int j = 0; j < dgv.Columns.Count; j++)  
31.                {  
32.                    table.Cell(i + 1, j + 1).Range.Text = dgv[j, i - 1].Value.ToString();  
33.                }  
34.            }  
35.            document.SaveAs(ref path, ref none, ref none, ref none, ref none, ref none,  
36.                ref none, ref none, ref none, ref none, ref none, ref none, ref none,  
37.                ref none, ref none, ref none);  
38.            document.Close(ref none, ref none, ref none);  
39.            MessageBox.Show("导出成功！");  
40.        }  
41.        finally  
42.        {  
43.            wordApp.Quit(ref none, ref none, ref none);  
44.        }  
45.    }  
46. }  

2.导出DataGridView中的数据到excel，实现代码如下：

1. /// <summary>  
2. /// 导出DataGridView中的数据到excel  
3. /// </summary>  
4. /// <param name="dataGridview1">DataGridView控件</param>  
5. public static void ExportDataGridViewToExcel(DataGridView dataGridview1)  
6. {  
7.    SaveFileDialog saveFileDialog = new SaveFileDialog();  
8.    saveFileDialog.Filter = "Execl files (*.xls)|*.xls";  
9.    saveFileDialog.FilterIndex = 0;  
10.    saveFileDialog.RestoreDirectory = true;  
11.    saveFileDialog.CreatePrompt = true;  
12.    saveFileDialog.Title = "导出Excel文件到";  
13.  
14.    saveFileDialog.ShowDialog();  
15.  
16.    Stream myStream;  
17.    myStream = saveFileDialog.OpenFile();  
18.    StreamWriter sw = new StreamWriter(myStream, System.Text.Encoding.GetEncoding("gb2312"));  
19.    string str = "";  
20.    try  
21.    {  
22.        //写标题    
23.        for (int i = 0; i < dataGridview1.ColumnCount; i++)  
24.        {  
25.            if (i > 0)  
26.            {  
27.                str += "\t";  
28.            }  
29.            str += dataGridview1.Columns.HeaderText;  
30.        }  
31.  
32.        sw.WriteLine(str);  
33.        //写内容  
34.        for (int j = 0; j < dataGridview1.Rows.Count; j++)  
35.        {  
36.            string tempStr = "";  
37.            for (int k = 0; k < dataGridview1.Columns.Count; k++)  
38.            {  
39.                if (k > 0)  
40.                {  
41.                    tempStr += "\t";  
42.                }  
43.                tempStr += dataGridview1.Rows[j].Cells[k].Value.ToString();  
44.            }  
45.            sw.WriteLine(tempStr);  
46.        }  
47.        sw.Close();  
48.        myStream.Close();  
49.    }  
50.    catch (Exception e)  
51.    {  
52.        MessageBox.Show(e.Message);  
53.    }  
54.    finally  
55.    {  
56.        sw.Close();  
57.        myStream.Close();  
58.    }  
59. }  

3.导入XML文件的数据到Oracle数据库

1. /// <summary>  
2. /// 导入XML文件的数据到Oracle数据库中  
3. /// </summary>  
4. /// <param name="strXmlFileName">Xml文件名称(完整的路径)</param>  
5. /// <param name="strDatabaseName">导入的数据库名称</param>  
6. public static void ImportXmlToOracle(string strXmlFileName, string strDatabaseName)  
7. {  
8.    NewDataSet nds = new NewDataSet();  
9.    string sql = string.Empty;  
10.  
11.    foreach (System.Data.DataTable dt in nds.Tables)  
12.    {  
13.        sql = "select * from ";  
14.        sql += strDatabaseName + "_" + dt.TableName;  
15.  
16.        OracleDataAdapter oda = new OracleDataAdapter(sql,  
17.                        ConfigurationSettings.AppSettings["ConnectionString"]);  
18.      
19.        OracleCommandBuilder builder = new OracleCommandBuilder(oda);  
20.        oda.Fill(nds.Tables[dt.TableName]);  
21.    }  
22.  
23.    try  
24.    {  
25.        XmlDocument doc = new XmlDocument();  
26.        doc.Load(strXmlFileName);  
27.        XmlNodeList nodeList = doc.GetElementsByTagName("tableType");  
28.        string strTableType = string.Empty;  
29.        foreach (XmlNode node in nodeList)  
30.        {  
31.            if (node.Name == "tableType")  
32.            {  
33.                strTableType += node.InnerText + ";";  
34.            }  
35.        }  
36.  
37.        strTableType = strTableType.Substring(0, strTableType.Length - 1);  
38.        foreach (XmlNode node in nodeList)  
39.        {  
40.            if (node.Name == "tableType")  
41.            {  
42.                node.InnerText = strTableType;  
43.                break;  
44.            }  
45.        }  
46.  
47.        nodeList = doc.GetElementsByTagName("graphOverview");  
48.        foreach (XmlNode node in nodeList)  
49.        {  
50.            if (node.Name == "graphOverview")  
51.            {  
52.                string str = string.Empty;  
53.                if (node.InnerText.IndexOf(".jpg".ToUpper()) != -1)  
54.                {  
55.                    str = node.InnerText.Substring(node.InnerText.IndexOf(".jpg".ToUpper()) + 4);  
56.                }  
57.                else if (node.InnerText.IndexOf(".jpg") != -1)  
58.                {  
59.                    str = node.InnerText.Substring(node.InnerText.IndexOf(".jpg") + 4);  
60.                }  
61.                node.InnerText = str;  
62.                  
63.                break;  
64.            }  
65.        }  
66.          
67.        doc.Save("temp.xml");  
68.        nds.ReadXml("temp.xml");  
69.        System.IO.File.Delete("temp.xml");  
70.  
71.        foreach (System.Data.DataTable dt in nds.Tables)  
72.        {  
73.            if (dt.Rows.Count > 0)  
74.            {  
75.                 string strTableName = strDatabaseName + "_" + dt.TableName;  
76.                 sql = "select * from " + strTableName;  
77.                 DataSet ds = new DataSet();  
78.  
79.                 OracleDataAdapter oda = new OracleDataAdapter(sql,  
80.                     ConfigurationSettings.AppSettings["ConnectionString"]);  
81.                 OracleCommandBuilder builder = new OracleCommandBuilder(oda);  
82.                 oda.Fill(ds);  
83.                 oda.Update(dt);  
84.             }  
85.         }  
86.    }  
87.    catch (Exception ex)  
88.    {  
89.        MessageBox.Show(ex.Message);  
90.        LogHelp.writeLog(FrmMain.metaUsername, "元数据目录管理",  
91.            "导入元数据文件<" + strXmlFileName + ">失败!");  
92.    }  
93. }  

    
这个函数主要用在元数据管理子系统，把XML格式的数据导入Oracle数据库，这里XML格式的文件是通过一个XSD文件定义格式得到的，XSD文件就
是Xml数据格式的约束文件，就是通过它定义XML具体的格式。然而微软有一个工具可以根据这个XSD文件生成对应的数据集类，在我的代码里就是
NewDataSet类。这个数据集类就可以管理对应的格式的所有XML生成的表结构数据。这里还需要说明一点的就是管理元数据需要一个单独的元数据库，
也就是要求重新建立一个Oracle数据库，但是用C#代码创建Oracle数据库确实很有难度，所以我选择了一种比较巧妙的实现方式，就是把所有属于元
数据的表用前缀标明（如metadata_名称），这样每次操作元数据库就只需要找到相应前缀的表就可以了，具体在元数据管理子系统有详细介绍实现方案。
    
因为XML文件里面包含有图片数据（经过64base编码的字符串表示），所以在处理XML文件需要先处理一下这个XML文件的图片字段，才有上面新建一
个临时的XML文件，然后用数据集类对象读入XML数据，然后删除临时的XML文件。最后还是例如数据集适配器来插入元数据到Oracle数据库。
4.根据元数据的ID删除一条元数据（从Oracle数据库）：

1. /// <summary>  
2. /// 根据元数据ID删除一条元数据，一条元数据涉及到每一个元数据库的表  
3. /// </summary>  
4. /// <param name="strMdid">元数据ID</param>  
5. /// <param name="strDatabaseName">元数据名称</param>  
6. public static void DelOneMetaData(string strMdid, string strDatabaseName)  
7. {  
8.    SqlHelper sh = new SqlHelper();  
9.    OracleConnection conn = new OracleConnection(ConfigurationSettings.AppSettings["ConnectionString"]);  
10.    conn.Open();  
11.    //创建一个 OracleTransaction 对象，然后调用 OracleConnection 对象  
12.    //的 BeginTransaction() 方法启动事务。  
13.    OracleTransaction trans = conn.BeginTransaction();  
14.    //创建一个 OracleCommand 对象，用于存储 SQL 语句。  
15.  
16.    OracleCommand cmd = conn.CreateCommand();  
17.    cmd.Transaction = trans;  
18.    string sql = string.Empty;  
19.    //xxx_metadata  
20.    sql = "delete from " + strDatabaseName + "_metadata";  
21.    sql += " where mdid like'" + strMdid + "'";  
22.    cmd.CommandText = sql;  
23.    cmd.ExecuteNonQuery();  
24.  
25.    sql = "select metadata_id from " + strDatabaseName + "_metadata";  
26.    sql += " where mdid like'" + strMdid + "'";  
27.    OracleDataReader odr1 = sh.ReturnDataReader(sql);  
28.    if (odr1.Read())  
29.    {  
30.        //xxx_continfo  
31.        sql = "delete from " + strDatabaseName + "_continfo";  
32.        sql += " where metadata_id=" + odr1[0].ToString();  
33.        cmd.CommandText = sql;  
34.        cmd.ExecuteNonQuery();  
35.  
36.        sql = "select continfo_id from " + strDatabaseName + "_continfo";  
37.        sql += " where metadata_id=" + odr1[0].ToString();  
38.        OracleDataReader odr2 = sh.ReturnDataReader(sql);  
39.        if (odr2.Read())  
40.        {  
41.            //xxx_layerinfo  
42.            sql = "delete from " + strDatabaseName + "_layerinfo";  
43.            sql += " where continfo_id=" + odr2[0].ToString();  
44.            cmd.CommandText = sql;  
45.            cmd.ExecuteNonQuery();  
46.            //xxx_tableinfo  
47.            sql = "delete from " + strDatabaseName + "_tableinfo";  
48.            sql += " where continfo_id=" + odr2[0].ToString();  
49.            cmd.CommandText = sql;  
50.            cmd.ExecuteNonQuery();  
51.        }  
52.        //xxx_graph  
53.        sql = "delete from " + strDatabaseName + "_graph";  
54.        sql += " where metadata_id=" + odr1[0].ToString();  
55.        cmd.CommandText = sql;  
56.        cmd.ExecuteNonQuery();  
57.        //xxx_idpoc  
58.        sql = "delete from " + strDatabaseName + "_idpoc";  
59.        sql += " where metadata_id=" + odr1[0].ToString();  
60.        cmd.CommandText = sql;  
61.        cmd.ExecuteNonQuery();  
62.  
63.        sql = "select idpoc_id from " + strDatabaseName + "_idpoc";  
64.        sql += " where metadata_id=" + odr1[0].ToString();  
65.        OracleDataReader odr3 = sh.ReturnDataReader(sql);  
66.        if (odr3.Read())  
67.        {  
68.            //xxx_contact  
69.            sql = "delete from " + strDatabaseName + "_contact";  
70.            sql += " where idpoc_id=" + odr3[0].ToString();  
71.            cmd.CommandText = sql;  
72.            cmd.ExecuteNonQuery();  
73.  
74.            sql = "select contact_id from " + strDatabaseName + "_contact";  
75.            sql += " where idpoc_id=" + odr3[0].ToString();  
76.            OracleDataReader odr4 = sh.ReturnDataReader(sql);  
77.            if (odr4.Read())  
78.            {  
79.                //xxx_cntadd  
80.                sql = "delete from " + strDatabaseName + "_cntadd";  
81.                sql += " where contact_id=" + odr4[0].ToString();  
82.                cmd.CommandText = sql;  
83.                cmd.ExecuteNonQuery();  
84.  
85.                //xxx_cntphone  
86.                sql = "delete from " + strDatabaseName + "_cntphone";  
87.                sql += " where contact_id=" + odr4[0].ToString();  
88.                cmd.CommandText = sql;  
89.                cmd.ExecuteNonQuery();  
90.  
91.                sql = "select cntphone_id from " + strDatabaseName + "_cntphone";  
92.                sql += " where contact_id=" + odr4[0].ToString();  
93.                OracleDataReader odr5 = sh.ReturnDataReader(sql);  
94.                if (odr5.Read())  
95.                {  
96.                    //xxx_voicenum  
97.                    sql = "delete from " + strDatabaseName + "_voicenum";  
98.                    sql += " where cntphone_id=" + odr4[0].ToString();  
99.                    cmd.CommandText = sql;  
100.                    cmd.ExecuteNonQuery();  
101.                }  
102.  
103.            }  
104.        }  
105.        //xxx_keyword  
106.        sql = "delete from " + strDatabaseName + "_keyword";  
107.        sql += " where metadata_id=" + odr1[0].ToString();  
108.        cmd.CommandText = sql;  
109.        cmd.ExecuteNonQuery();  
110.        //xxx_onlinesrc  
111.        sql = "delete from " + strDatabaseName + "_onlinesrc";  
112.        sql += " where metadata_id=" + odr1[0].ToString();  
113.        cmd.CommandText = sql;  
114.        cmd.ExecuteNonQuery();  
115.  
116.        sql = "select onlinesrc_id from " + strDatabaseName + "_onlinesrc";  
117.        sql += " where metadata_id=" + odr1[0].ToString();  
118.        OracleDataReader odr6 = sh.ReturnDataReader(sql);  
119.        if (odr6.Read())  
120.        {  
121.            //xxx_dtbrlinkage  
122.            sql = "delete from " + strDatabaseName + "_dtbrlinkage";  
123.            sql += " where onlinesrc_id=" + odr6[0].ToString();  
124.            cmd.CommandText = sql;  
125.            cmd.ExecuteNonQuery();  
126.  
127.            //xxx_dtdllinkage  
128.            sql = "delete from " + strDatabaseName + "_dtdllinkage";  
129.            sql += " where onlinesrc_id=" + odr6[0].ToString();  
130.            cmd.CommandText = sql;  
131.            cmd.ExecuteNonQuery();  
132.        }  
133.        //xxx_tpcat  
134.        sql = "delete from " + strDatabaseName + "_tpcat";  
135.        sql += " where metadata_id=" + odr1[0].ToString();  
136.        cmd.CommandText = sql;  
137.        cmd.ExecuteNonQuery();  
138.        try  
139.        {  
140.            trans.Commit();  
141.        }  
142.        catch (Exception)  
143.        {  
144.            trans.Rollback();  
145.            LogHelp.writeLog(FrmMain.metaUsername, "元数据编辑", "删除元数据<" + strMdid + ">失败！");  
146.            MessageBox.Show("删除元数据<" + strMdid + ">失败！");  
147.        }  
148.        finally  
149.        {  
150.            conn.Close();  
151.        }  
152.    }  
153. }  

    因为根据XSD文件解析生成的数据库表有十几个，所以对每一个表单独采用事务操作，就是这十几个表其实是一个整体，可以完整的表示一条元数据（元数据：描述数据的数据，这里就是描述空间数据特性的数据）。
5.根据元数据的ID从Oracle查询得到一条元数据，和删除一条元数据类似，也需要十几个表一起操作：

1. /// <summary>  
2. /// 根据元数据ID得到有一条元数据的数据集  
3. /// </summary>  
4. /// <param name="strMdid">元数据ID</param>  
5. /// <param name="strDatabaseName">元数据名称</param>  
6. /// <returns></returns>  
7. public static NewDataSet GetOneMetaData(string strMdid, string strDatabaseName)  
8. {  
9.     NewDataSet nds = new NewDataSet();  
10.     SqlHelper sh = new SqlHelper();  
11.  
12.     string sql = string.Empty;  
13.     //xxx_metadata  
14.     sql = "select * from " + strDatabaseName + "_metadata";  
15.     sql += " where mdid like'" + strMdid + "'";  
16.     OracleDataAdapter oda1 = new OracleDataAdapter(sql,  
17.         ConfigurationSettings.AppSettings["ConnectionString"]);  
18.     oda1.Fill(nds.Tables["metadata"]);  
19.  
20.     sql = "select metadata_id from " + strDatabaseName + "_metadata";  
21.     sql += " where mdid like'" + strMdid + "'";  
22.     OracleDataReader odr1 = sh.ReturnDataReader(sql);  
23.     if (odr1.Read())  
24.     {  
25.         //xxx_continfo  
26.         sql = "select * from " + strDatabaseName + "_continfo";  
27.         sql += " where metadata_id=" + odr1[0].ToString();  
28.         OracleDataAdapter oda2 = new OracleDataAdapter(sql,  
29.             ConfigurationSettings.AppSettings["ConnectionString"]);  
30.         oda2.Fill(nds.Tables["continfo"]);  
31.  
32.         sql = "select continfo_id from " + strDatabaseName + "_continfo";  
33.         sql += " where metadata_id=" + odr1[0].ToString();  
34.         OracleDataReader odr2 = sh.ReturnDataReader(sql);  
35.         if (odr2.Read())  
36.         {  
37.             //xxx_layerinfo  
38.             sql = "select * from " + strDatabaseName + "_layerinfo";  
39.             sql += " where continfo_id=" + odr2[0].ToString();  
40.             OracleDataAdapter oda8 = new OracleDataAdapter(sql,  
41.                 ConfigurationSettings.AppSettings["ConnectionString"]);  
42.             oda8.Fill(nds.Tables["layerinfo"]);  
43.             //xxx_tableinfo  
44.             sql = "select * from " + strDatabaseName + "_tableinfo";  
45.             sql += " where continfo_id=" + odr2[0].ToString();  
46.             OracleDataAdapter oda9 = new OracleDataAdapter(sql,  
47.                 ConfigurationSettings.AppSettings["ConnectionString"]);  
48.             oda9.Fill(nds.Tables["tableinfo"]);  
49.         }  
50.         //xxx_graph  
51.         sql = "select * from " + strDatabaseName + "_graph";  
52.         sql += " where metadata_id=" + odr1[0].ToString();  
53.         OracleDataAdapter oda3 = new OracleDataAdapter(sql,  
54.             ConfigurationSettings.AppSettings["ConnectionString"]);  
55.         oda3.Fill(nds.Tables["graph"]);  
56.         //xxx_idpoc  
57.         sql = "select * from " + strDatabaseName + "_idpoc";  
58.         sql += " where metadata_id=" + odr1[0].ToString();  
59.         OracleDataAdapter oda4 = new OracleDataAdapter(sql,  
60.             ConfigurationSettings.AppSettings["ConnectionString"]);  
61.         oda4.Fill(nds.Tables["idpoc"]);  
62.  
63.         sql = "select idpoc_id from " + strDatabaseName + "_idpoc";  
64.         sql += " where metadata_id=" + odr1[0].ToString();  
65.         OracleDataReader odr3 = sh.ReturnDataReader(sql);  
66.         if (odr3.Read())  
67.         {  
68.             //xxx_contact  
69.             sql = "select * from " + strDatabaseName + "_contact";  
70.             sql += " where idpoc_id=" + odr3[0].ToString();  
71.             OracleDataAdapter oda12 = new OracleDataAdapter(sql,  
72.                 ConfigurationSettings.AppSettings["ConnectionString"]);  
73.             oda12.Fill(nds.Tables["contact"]);  
74.  
75.             sql = "select contact_id from " + strDatabaseName + "_contact";  
76.             sql += " where idpoc_id=" + odr3[0].ToString();  
77.             OracleDataReader odr4 = sh.ReturnDataReader(sql);  
78.             if (odr4.Read())  
79.             {  
80.                 //xxx_cntadd  
81.                 sql = "select * from " + strDatabaseName + "_cntadd";  
82.                 sql += " where contact_id=" + odr4[0].ToString();  
83.                 OracleDataAdapter oda13 = new OracleDataAdapter(sql,  
84.                     ConfigurationSettings.AppSettings["ConnectionString"]);  
85.                 oda13.Fill(nds.Tables["cntadd"]);  
86.  
87.                 //xxx_cntphone  
88.                 sql = "select * from " + strDatabaseName + "_cntphone";  
89.                 sql += " where contact_id=" + odr4[0].ToString();  
90.                 OracleDataAdapter oda14 = new OracleDataAdapter(sql,  
91.                     ConfigurationSettings.AppSettings["ConnectionString"]);  
92.                 oda14.Fill(nds.Tables["cntphone"]);  
93.  
94.                 sql = "select cntphone_id from " + strDatabaseName + "_cntphone";  
95.                 sql += " where contact_id=" + odr4[0].ToString();  
96.                 OracleDataReader odr5 = sh.ReturnDataReader(sql);  
97.                 if (odr5.Read())  
98.                 {  
99.                     //xxx_voicenum  
100.                     sql = "select * from " + strDatabaseName + "_voicenum";  
101.                     sql += " where cntphone_id=" + odr4[0].ToString();  
102.                     OracleDataAdapter oda15 = new OracleDataAdapter(sql,  
103.                         ConfigurationSettings.AppSettings["ConnectionString"]);  
104.                     oda15.Fill(nds.Tables["voicenum"]);  
105.                 }  
106.  
107.             }  
108.         }  
109.         //xxx_keyword  
110.         sql = "select * from " + strDatabaseName + "_keyword";  
111.         sql += " where metadata_id=" + odr1[0].ToString();  
112.         OracleDataAdapter oda5 = new OracleDataAdapter(sql,  
113.             ConfigurationSettings.AppSettings["ConnectionString"]);  
114.         oda5.Fill(nds.Tables["keyword"]);  
115.         //xxx_onlinesrc  
116.         sql = "select * from " + strDatabaseName + "_onlinesrc";  
117.         sql += " where metadata_id=" + odr1[0].ToString();  
118.         OracleDataAdapter oda6 = new OracleDataAdapter(sql,  
119.             ConfigurationSettings.AppSettings["ConnectionString"]);  
120.         oda6.Fill(nds.Tables["onlinesrc"]);  
121.  
122.         sql = "select onlinesrc_id from " + strDatabaseName + "_onlinesrc";  
123.         sql += " where metadata_id=" + odr1[0].ToString();  
124.         OracleDataReader odr6 = sh.ReturnDataReader(sql);  
125.         if (odr6.Read())  
126.         {  
127.             //xxx_dtbrlinkage  
128.             sql = "select * from " + strDatabaseName + "_dtbrlinkage";  
129.             sql += " where onlinesrc_id=" + odr6[0].ToString();  
130.             OracleDataAdapter oda10 = new OracleDataAdapter(sql,  
131.                 ConfigurationSettings.AppSettings["ConnectionString"]);  
132.             oda10.Fill(nds.Tables["dtbrlinkage"]);  
133.  
134.             //xxx_dtdllinkage  
135.             sql = "select * from " + strDatabaseName + "_dtdllinkage";  
136.             sql += " where onlinesrc_id=" + odr6[0].ToString();  
137.             OracleDataAdapter oda11 = new OracleDataAdapter(sql,  
138.                 ConfigurationSettings.AppSettings["ConnectionString"]);  
139.             oda11.Fill(nds.Tables["dtdllinkage"]);  
140.         }  
141.         //xxx_tpcat  
142.         sql = "select * from " + strDatabaseName + "_tpcat";  
143.         sql += " where metadata_id=" + odr1[0].ToString();  
144.         OracleDataAdapter oda7 = new OracleDataAdapter(sql,  
145.             ConfigurationSettings.AppSettings["ConnectionString"]);  
146.         oda7.Fill(nds.Tables["tpcat"]);  
147.     }  
148.     return nds;  
149. }  

6.导出Oracle数据库的数据到XML文件中

1. /// <summary>  
2. /// 导出Oracle数据库的数据到XML文件中  
3. /// </summary>  
4. /// <param name="strXmlPath">导出的目录</param>  
5. /// <param name="strDatabaseName">导出的数据库名称</param>  
6. public static void ExportXmlFromOracle(string strXmlPath, string strDatabaseName)  
7. {  
8.    NewDataSet nds;  
9.    SqlHelper sh = new SqlHelper();  
10.    string sql = string.Empty;  
11.    sql = "select mdid from " + strDatabaseName + "_metadata";  
12.  
13.    OracleDataReader odr = sh.ReturnDataReader(sql);  
14.  
15.    while (odr.Read())  
16.    {  
17.        string strMdid = odr[0].ToString();  
18.        //根据元数据的ID得到一条元数据  
19.        nds = GetOneMetaData(strMdid, strDatabaseName);  
20.  
21.        nds.WriteXml(strXmlPath + "\\" + strMdid + ".xml");  
22.    }  
23. }  

7.下面两个函数实现treeview控件向XML转换，主要用于对元数据的编辑后保存到XML文件中。

1. #region 遍历tree并实现向XML的转化  
2. /// <summary>        
3. /// 遍历treeview并实现向XML的转化    
4. /// </summary>        
5. /// <param name="advTree">树控件对象</param>        
6. /// <param name="strXmlFilePath">XML输出路径</param>  
7. public static void TreeToXML(AdvTree advTree, string strXmlFilePath)  
8. {  
9.    XmlTextWriter xtw = new XmlTextWriter(strXmlFilePath, null);  
10.    XmlDocument xmlDoc = new XmlDocument();  
11.    //控制格式并写XML的开头  
12.    xtw.Formatting = Formatting.Indented;  
13.    xtw.WriteStartDocument(true);  
14.    xtw.WriteStartElement("metadata");  
15.    xtw.WriteStartAttribute("xsi","noNamespaceSchemaLocation", "http://www.w3.org/2001/XMLSchema-instance");  
16.    xtw.WriteEndAttribute();  
17.    xtw.WriteEndElement();  
18.    xtw.WriteEndDocument();  
19.    xtw.Close();  
20.  
21.    xmlDoc.Load(strXmlFilePath);  
22.    XmlNode xnRoot = xmlDoc.SelectSingleNode("metadata");  
23.  
24.    TransTreeToXml(xmlDoc, advTree.FindNodeByName("metadata").Nodes, (XmlElement)xnRoot, strXmlFilePath);  
25. }  
26.  
27. /// <summary>  
28. /// 转化Tree节点的数据到XML文档  
29. /// </summary>  
30. /// <param name="xmlDoc">XML文档对象</param>  
31. /// <param name="nodes">Tree的节点集合</param>  
32. /// <param name="xeRoot">根节点元素</param>  
33. /// <param name="strXmlPath">XML的节点路径</param>  
34. private static void TransTreeToXml(XmlDocument xmlDoc,  
35.    NodeCollection nodes, XmlElement xeRoot, String strXmlPath)  
36. {  
37.    XmlElement xe;  
38.    //遍历节点集合中的所有节点  
39.    foreach (Node node in nodes)  
40.    {  
41.        //根据节点的名称创建一个新的XML节点元素  
42.        xe = xmlDoc.CreateElement(node.Name);  
43.        //将新建的XML节点元素添加到父亲节点（也就是传递进来的根节点）  
44.        xeRoot.AppendChild(xe);  
45.        //如果节点还有子节点就递归调用本函数  
46.        if (node.Nodes.Count > 0)  
47.        {  
48.            TransTreeToXml(xmlDoc, node.Nodes, xe, strXmlPath);  
49.        }  
50.        else  
51.        {  
52.            //因为Tree节点数据的格式是：（名称：值），所以根据格式取出具体的值  
53.            string strTemp = node.Text.Substring(node.Text.IndexOf(':')+1);  
54.            //这个值不是空就填写新建的XML节点的值  
55.            if (strTemp != "")  
56.            {  
57.                //特殊处理graphOverview节点，因为它涉及到图形的二进制数据，需要转化为字符串  
58.                if (xe.Name == "graphOverview")  
59.                {  
60.                    //以下就是将图形二进制数据转化为字符串  
61.                    Bitmap bmp = new Bitmap(strTemp);  
62.                    MemoryStream ms = new MemoryStream();    
63.                    bmp.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);    
64.                    byte[] arr = new byte[ms.Length];    
65.                    ms.Position = 0;    
66.                    ms.Read(arr, 0, (int)ms.Length);    
67.                    ms.Close();    
68.                    String strbaser64 = Convert.ToBase64String(arr);  
69.                    //给节点填充值  
70.                    xe.InnerText = strbaser64;  
71.                }  
72.                else  
73.                {  
74.                    //给节点填充值  
75.                    xe.InnerText = strTemp;  
76.                }  
77.            }  
78.        }  
79.    }  
80.    xmlDoc.Save(strXmlPath);  
81. }  
83. #endregion  

8.遍历XML并实现向tree控件的转化

1. #region 遍历XML并实现向tree的转化  
2. /// <summary>        
3. /// 遍历XML并实现向tree的转化  
4. /// </summary>        
5. /// <param name="strXmlFilePath">XML输入路径</param>        
6. /// <param name="advTree">树控件对象</param>    
7. public static void XMLToTree(string strXmlFilePath, AdvTree advTree)  
8. {  
9.    //新建XML文档对象并载入XML文件数据  
10.    XmlDocument xmlDoc = new XmlDocument();  
11.    xmlDoc.Load(strXmlFilePath);  
12.    //找到根节点  
13.    XmlNodeList xnl = xmlDoc.GetElementsByTagName("metadata");  
14.    XmlNode root = xnl[0];  
15.    //根据找到的根节点遍历整个XML文件的节点  
16.    foreach (XmlNode xn in root.ChildNodes)  
17.    {  
18.        //找到Tree对于的节点  
19.        Node n = advTree.FindNodeByName(xn.Name);  
20.        //如果有子节点就调用递归转化函数  
21.        if (n.HasChildNodes)  
22.        {  
23.            TransXMLToTree(xn.ChildNodes, advTree);  
24.        }  
25.        else  
26.        {  
27.            //如果节点的内容不为空就为Tree控件节点添加值  
28.            if (xn.InnerText != "")  
29.            {  
30.                //标记已经有值，方便以后对Tree的编辑操作  
31.                n.Tag = "yes";  
32.                n.Text += xn.InnerText;  
33.                //如果此节点有父亲节点就把对于的父亲节点也标记为有值  
34.                while (n.Parent != null)  
35.                {  
36.                    Node np = n.Parent;  
37.                    np.Tag = "yes";  
38.                    n = n.Parent;  
39.                }  
40.            }  
41.        }  
42.    }  
43. }  
44.  
45. /// <summary>  
46. /// 递归转化XML文件的节点到Tree的节点  
47. /// </summary>  
48. /// <param name="xmlNodes">XML文件的节点集合</param>  
49. /// <param name="advTree">Tree控件</param>  
50. private static void TransXMLToTree(XmlNodeList xmlNodes, AdvTree advTree)  
51. {  
52.    //循环遍历节点集合  
53.    foreach (XmlNode xn in xmlNodes)  
54.    {  
55.        //根据XML的节点找到对于的Tree节点  
56.        Node n = advTree.FindNodeByName(xn.Name);  
57.        //如果还有子节点就递归转换  
58.        if (n.HasChildNodes)  
59.        {  
60.            TransXMLToTree(xn.ChildNodes, advTree);  
61.        }  
62.        else  
63.        {  
64.            //如果节点的内容不为空就为Tree控件节点添加值  
65.            if (xn.InnerText != "")  
66.            {  
67.                //标记已经有值，方便以后对Tree的编辑操作  
68.                n.Tag = "yes";  
69.                n.Text += xn.InnerText;  
70.                //如果此节点有父亲节点就把对于的父亲节点也标记为有值  
71.                while (n.Parent != null)  
72.                {  
73.                    Node np = n.Parent;  
74.                    np.Tag = "yes";  
75.                    n = n.Parent;  
76.                }  
77.            }  
78.        }  
79.    }  
80. }  
81. #endregion  

9.将DataGridView显示的内容导出Excel

1. /// <summary>  
2. /// 直接将DataGridView显示的内容导出Excel  
3. /// </summary>  
4. /// <param name="m_DataView"></param>  
5. public static void DataToExcel(DataGridView m_DataView)  
6. {  
7.    int iRows = 0;    
8.    int iCols = 0;    
9.    int iTrueCols = 0;    
10.    Microsoft.Office.Interop.Excel.Application app = new Microsoft.Office.Interop.Excel.Application();    
11.    Microsoft.Office.Interop.Excel._Workbook wb = app.Workbooks.Add(System.Reflection.Missing.Value);    
12.    Microsoft.Office.Interop.Excel._Worksheet ws = null;    
13.    if (wb.Worksheets.Count > 0)    
14.    {      
15.        ws = (Microsoft.Office.Interop.Excel.Worksheet)wb.Worksheets.get_Item(1);    
16.    }    
17.    else    
18.    {    
19.        wb.Worksheets.Add(System.Reflection.Missing.Value, System.Reflection.Missing.Value,  
20.            System.Reflection.Missing.Value, System.Reflection.Missing.Value);    
21.        ws = (Microsoft.Office.Interop.Excel.Worksheet)wb.Worksheets.get_Item(1);    
22.    }    
23.    if (ws != null)      
24.    {    
25.        ws.Name = "sheet1";  
26.        iRows = m_DataView.Rows.Count;          //加上列头行    
27.        iTrueCols = m_DataView.Columns.Count;   //包含隐藏的列，一共有多少列      
28.        //求列数，省略Visible = false的列    
29.        for (int i = 0; i < m_DataView.Columns.Count; i++)    
30.        {    
31.           if (m_DataView.Columns.Visible) iCols++;    
32.        }    
33.        string[,] dimArray = new string[iRows + 1, iCols];    
34.  
35.        for (int j = 0, k = 0; j < iTrueCols; j++)    
36.        {    
37.            //省略Visible = false的列  
38.            if (m_DataView.Columns[j].Visible)    
39.            {    
40.                dimArray[0, k] = m_DataView.Columns[j].HeaderText;    
41.                k++;    
42.            }    
43.        }    
44.        for (int i = 0; i < iRows; i++)    
45.        {    
46.            for (int j = 0, k = 0; j < iTrueCols; j++)    
47.            {    
48.                //省略Visible = false的列  
49.                if (m_DataView.Columns[j].Visible)    
50.                {  
51.                    if (m_DataView.Rows.Cells[j].Value != null)  
52.                    {  
53.                        dimArray[i + 1, k] = m_DataView.Rows.Cells[j].Value.ToString();  
54.                    }  
55.                        
56.                    k++;    
57.                }    
58.            }    
59.        }      
60.        ws.get_Range(ws.Cells[1, 1], ws.Cells[iRows + 1, iCols]).Value2 = dimArray;      
61.        ws.get_Range(ws.Cells[1, 1], ws.Cells[1, iCols]).Font.Bold = true;    
62.        ws.get_Range(ws.Cells[1, 1], ws.Cells[iRows + 1, iCols]).Font.Size = 10.0;      
63.        ws.get_Range(ws.Cells[1, 1], ws.Cells[iRows + 1, iCols]).RowHeight = 14.25;    
64.       //ws.Columns[.ColumnWidth = datagridview.Columns[0].Width;    
65.        for (int j = 0, k = 0; j < iTrueCols; j++)    
66.        {    
67.            //省略Visible = false的列  
68.            if (m_DataView.Columns[j].Visible)    
69.            {    
70.                ws.get_Range(ws.Cells[1, k + 1], ws.Cells[1, k + 1]).ColumnWidth =  
71.                    (m_DataView.Columns[j].Width / 8.4) > 255 ? 255 : (m_DataView.Columns[j].Width / 8.4);    
72.                //ws.Columns.c = datagridview.Columns[j].Width;    
73.                k++;    
74.            }    
75.        }    
76.    }  
77.    //设置禁止弹出保存和覆盖的询问提示框    
78.    app.DisplayAlerts = false;  
79.    app.AlertBeforeOverwriting = false;  
80.    app.Visible = false;  
81.    //保存工作簿    
82.    try  
83.    {  
84.        app.Save("temp");  
85.    }  
86.    catch (System.Exception ex)  
87.    {  
88.        MessageBox.Show(ex.Message);  
89.    }  
90.    finally  
91.    {  
92.        app.UserControl = false;  
93.        app.Quit();  
94.        File.Delete("temp.xlwx");  
95.    }  
96. }  

10.excel数据导入到DataGridView控件中

1. /// <summary>  
2. /// Excel数据导入方法  
3. /// </summary>  
4. /// <param name="filePath"></param>  
5. /// <param name="dgv"></param>  
6. public static void EcxelToDataGridView(string filePath, DataGridView dgv)  
7. {  
8.    try  
9.    {  
10.        //根据路径打开一个Excel文件并将数据填充到DataSet中  
11.        string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source = " + filePath + ";Extended Properties ='Excel 8.0'";  
12.        OleDbConnection conn = new OleDbConnection(strConn);  
13.        conn.Open();  
14.        string strExcel = "";  
15.        OleDbDataAdapter myCommand = null;  
16.        DataSet ds = null;  
17.        strExcel = "select  * from   [sheet1$]";  
18.        myCommand = new OleDbDataAdapter(strExcel, strConn);  
19.        ds = new DataSet();  
20.        myCommand.Fill(ds, "table1");  
21.  
22.        //根据Excel的行逐一对上面构造的DataTable的列进行赋值  
23.        foreach (DataRow excelRow in ds.Tables[0].Rows)  
24.        {  
25.            int i = 0;  
26.            DataRow dr = ((System.Data.DataTable)dgv.DataSource).Rows.Add();  
27.            for (i = 0; i < ds.Tables[0].Columns.Count; ++i)  
28.            {  
29.                dr[i + 1] = excelRow;  
30.            }  
31.        }  
32.    }  
33.    catch (System.Exception ex)  
34.    {  
35.        MessageBox.Show(ex.Message);  
36.    }  
37. }  

11.数据备份与恢复

1. /// <summary>  
2. /// 数据库备份或恢复  
3. /// </summary>  
4. /// <param name="strCmd">备份或恢复命令</param>  
5. /// <param name="strDmpFileName">dmp文件名称</param>  
6. /// <param name="strLogFileName">log文件名称</param>  
7. /// <returns>true:成功;false:失败</returns>  
8. public static bool DBBackup(string strCmd, string strDmpFileName, string strLogFileName)  
9. {  
10.    // 返回值  
11.    bool result = false;  
12.    // cmd中输入的参数内容  
13.    string arg = strCmd + " FILE= " + strDmpFileName + " LOG= " + strLogFileName;  
14.    try  
15.    {  
16.        // 如果dmp文件不存在，创建文件并释放  
17.        if (!File.Exists(strDmpFileName))  
18.        {  
19.            File.Create(strDmpFileName).Dispose();  
20.        }  
21.        // 如果log文件不存在，创建文件并释放  
22.        if (!File.Exists(strLogFileName))  
23.        {  
24.            File.Create(strLogFileName).Dispose();  
25.        }  
26.        // 开启新进程  
27.        Process p = new Process();  
28.        // 打开运行cmd  
29.        p.StartInfo.FileName = "cmd.exe";  
30.        // 要运行的命令  
31.        p.StartInfo.Arguments = arg;  
32.          
33.        // 关闭shell的使用  
34.        p.StartInfo.UseShellExecute = false;  
35.        //p.StartInfo.RedirectStandardInput = true;  
36.        // 设置显示cmd运行界面  
37.        p.StartInfo.CreateNoWindow = false;  
38.  
39.        // 启动进程  
40.        p.Start();  
41.          
42.        p.WaitForExit();  
43.        p.Dispose();  
44.        result = true;  
45.    }  
46.    catch (Exception ex)  
47.    {  
48.        MessageBox.Show(ex.Message);  
49.        return false;  
50.    }  
51.    return result;  
52. }  

   总结：这些功能放在一个类中可能不是很合理，但是当时是为了自己编程的方便，只要有多处实现的一些独立的功能，我就加入到这个类中来，并全部用静态的方法实现。

 上一篇文章把整个系统的主界面实现了，接下来就是实现主界面上提供的各个功能模块。首先介绍的是通用数据管理模块，为什么称为通用数据呢？因为这些数据和我们平时使用关系型数据库管理的数据是类似的，这里称为通用数据主要是为了和空间数据做区别。
    
该模块采用统一的界面来管理所有属性数据表，可以同时做添加、删除和修改，而且对于每一个表都是通用的操作。用户选择修改的表以后就建立一个数据集和这个
表关联，再将这个数据集绑定到数据显示控件上，同时将数据集绑定到数据适配器上，当用户对这个表的编辑操作完成以后并点击保存按钮就会将所有的更新操作与
数据库同步，这些功能都是调用数据适配器的接口完成。在与数据库同步的时候会先查看是否有与之相关联的表也需要同步更新，如果有就先更新关联的表。为了保
证数据库中数据的一致性和完整性，就必须保证所有更新操作都能成功的完成或者都不完成，所以所有更新操作都在一个事务中进行，如果更新过程中遇到异常就回
滚到最初状态。整个过程的流程图如下：
 

    
第一篇文章介绍这个功能的时候，我贴出了这个模块运行的界面，从界面可以看出主要用到了两个控件，左边是一个树形控件用于按类别显示所有的属性表的名称，
通过鼠标就可以选择一个需要查看、修改的表，右边是一个绑定了数据集的表数据显示控件，在这个控件中可以删除、添加和修改表的内容。除了这两个主要控件以
外，就是一些用于显示文本提示的label控件和一些按钮控件，按钮主要用于控制用户具体的某种操作，后面会详细介绍每一个按钮功能的实现。
    首先定义了一些类的成员变量，每一个成员变量的作用如下代码和注释所示：


1 private OracleCommandBuilder builder;//用于构建适配器命令 2 private OracleDataAdapter da; //数据集适配器，用于同步控件与数据库的操作 3 private DataSet ds;//数据集，可以是一个表也可以是多个表的集合 4 private string selectedNodeText;//记录树形节点选择的文本 5 private string tableName;//记录表的名称 6 protected OracleConnection Connection;//Oracle连接 7 private bool isChanged = false;//控件绑定的数据是否有改变 8 private FrmShowLayer fsl;//用于显示有空间对应表的可视化图形（地图）显示 9 private bool bIdChange = false;//判断表中的ID字段是否有改变，因为ID改变了会涉及到不同的操作 10 private bool bIdDel = false;//ID字段是否有删除，用于级联删除 11 private bool bCellValueChange = false;//数据是否有改变 12 private ArrayList newIdList;//用于保存新增列的ID字段 13 private ArrayList oldIdList;//用于保存被改变列以前的ID字段 14 private ArrayList delIdList;//用于保存删除列的ID字段


 接着构造函数初始化一些变量：

1 newIdList = new ArrayList(); 2 oldIdList = new ArrayList(); 3 delIdList = new ArrayList();

在对话框或form的Load函数中初始化一些其他变量：


1 //Connection = new OracleConnection("Data Source=JCSJK;User Id=dzyj_jcsjk;Password=dzyj_jcsjk"); 2 Connection = new OracleConnection(ConfigurationSettings.AppSettings["ConnectionString"]); 3 4 Node tn = new Node(); 5 tn.Text = "通用数据库管理"; 6 7 DataManagerTree.Nodes.Add(tn); 8 tn.Nodes.Add(new Node()); 9 labelX1.Text += FrmMain.username;//显示登录的用户名


 
    上面代码首先初始化Oracle的链接对象，然后为树形控件添加一个根节点，添加具体的表分类目录和具体的表名称节点是在具体展开某一个节点的时候完成，这样启动这个功能界面的时候不会让用户等待太久，这个就是延迟初始化或加载。当然这种方式也有一个不好的地方，就是每次展开一个节点都会去重新初始化，这样会降低一些用户的体验，而且程序执行很多不必要的重复工作。不过这个还是有解决方案的，就是首先判断展开节点下面的子节点是否已经加载，如果已经加载就直接展开就可以了，不用再去重新新添加和初始化节点了。下面来具体解析怎样实现数据的修改操作。
    说明：所有的操作都要通过保存按钮功能才是真正的同步到数据库，可以同时做添加、删除和修改操作以后一次性同步到数据库，而且对于所有表都是同样的操作，不过同时只能编辑一个表，如果编辑一个表以后没有点击保存按钮保存到数据库，那么所有的操作将会并取消。
1.删除操作，通过用户点击删除按钮触发，具体代码实现如下：


1 /// <summary> 2 /// 删除按钮的响应事件实现 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void deleteBtn_Click(object sender, EventArgs e) 7 { 8 //首先判断控件是否允许删除，不允许就让它允许 9 if (!dataGridViewX1.AllowUserToDeleteRows) 10 { 11 dataGridViewX1.AllowUserToDeleteRows = true; 12 } 13 if (dataGridViewX1.CurrentRow.Index < 0) 14 { 15 MessageBox.Show("请选择需要删除的一行"); 16 return; 17 } 18 19 //判断是不是这几个表，如果是会涉及到级联删除 20 if (selectedNodeText == "DZYJ_JCSJK.city_code" || selectedNodeText == "DZYJ_JCSJK.county_code" 21 || selectedNodeText == "DZYJ_JCSJK.town_code" || selectedNodeText == "DZYJ_JCSJK.village_code" 22 || selectedNodeText == "DZYJ_JCSJK.enterprise_code") 23 { 24 if (MessageBox.Show("删除这条记录会删除与之相关的其他表记录，确认删除？", "确认信息", 25 MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes) 26 { 27 bIdDel = true; 28 if (delIdList == null) 29 { 30 delIdList = new ArrayList(); 31 } 32 delIdList.Add(dataGridViewX1.CurrentRow.Cells["ID"].Value.ToString()); 33 } 34 else 35 { 36 return; 37 } 38 } 39 40 //ds.Tables[0].Rows[dataGridViewX1.CurrentRow.Index].Delete(); 41 dataGridViewX1.Rows.Remove(dataGridViewX1.CurrentRow);//移除选择的当前行 42 isChanged = true;//设置改变为真 43 saveBtn.Enabled = true;//使能保存按钮，保存按钮实现将改变同步到数据库中去 44 //dataGridViewX1.Refresh(); 45 }


 
2.添加操作


1 /// <summary> 2 /// 添加按钮事件响应函数 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void addBtn_Click(object sender, EventArgs e) 7 { 8 /*if (!dataGridViewX1.AllowUserToAddRows) 9 { 10 dataGridViewX1.AllowUserToAddRows = true; 11 }*/ 12 ((DataTable)dataGridViewX1.DataSource).Rows.Add();//添加一行用于插入数据 13 if (dataGridViewX1.ReadOnly)//如果控件是只读属性让它可以编辑 14 { 15 dataGridViewX1.ReadOnly = false; 16 } 17 isChanged = true; 18 saveBtn.Enabled = true; 19 dataGridViewX1.FirstDisplayedScrollingRowIndex = 20 dataGridViewX1.Rows[dataGridViewX1.RowCount-1].Index;//视图定位到添加这一行 21 }


 

 3.编辑或更新操作（对于数据库的update）


1 /// <summary> 2 /// 修改按钮事件，使能DataGridView的编辑功能 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void modifyBtn_Click(object sender, EventArgs e) 7 { 8 if (dataGridViewX1.ReadOnly) 9 { 10 dataGridViewX1.ReadOnly = false; 11 } 12 saveBtn.Enabled = true; 13 }

 4.保存操作，真正就改变的数据同步到数据库中去，重要功能实现：


1 /// <summary> 2 /// 更新修改后的数据到数据库中去 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void saveBtn_Click(object sender, EventArgs e) 7 { 8 int result = 0; 9 if (isChanged) 10 { 11 OracleConnection conn = new OracleConnection(ConfigurationSettings.AppSettings["ConnectionString"]); 12 conn.Open(); 13 // 创建一个 OracleTransaction 对象，然后调用 OracleConnection 对象 14 //的 BeginTransaction() 方法启动事务。 15 OracleTransaction trans = conn.BeginTransaction(); 16 // 创建一个 OracleCommand 对象，用于存储 SQL 语句。 17 OracleCommand cmd = conn.CreateCommand(); 18 cmd.Transaction = trans; 19 try 20 { 21 //如果有ID改变或删除就级联更新 22 if (bIdChange || bIdDel) 23 { 24 UpdateRelationTable(cmd); 25 } 26 result = da.Update(ds, tableName); 27 if (bIdChange || bIdDel) 28 { 29 trans.Commit(); 30 } 31 } 32 catch (Exception ex) 33 { 34 //出现异常就回滚 35 if (bIdChange || bIdDel) 36 { 37 trans.Rollback(); 38 } 39 MessageBox.Show(ex.Message); 40 } 41 finally 42 { 43 if (bIdChange || bIdDel) 44 { 45 newIdList.Clear(); 46 oldIdList.Clear(); 47 delIdList.Clear(); 48 } 49 } 50 } 51 isChanged = false; 52 bIdDel = false; 53 bIdChange = false; 54 dataGridViewX1.ReadOnly = true; 55 dataGridViewX1.AllowUserToAddRows = false; 56 dataGridViewX1.AllowUserToDeleteRows = false; 57 saveBtn.Enabled = false; 58 //如果有数据行被更新到数据库，会把具体的操作记录到日志表中 59 if (result > 0) 60 { 61 //0表示普通表,1空间表 62 Node tn = DataManagerTree.FindNodeByText(selectedNodeText); 63 if (tn.Parent.Text != "属性表") 64 { 65 LogHelp.writeUpdateDataLog(tableName, "1", "修改"); 66 } 67 else 68 { 69 LogHelp.writeUpdateDataLog(tableName, "0", "修改"); 70 } 71 72 LogHelp.writeLog(FrmMain.username, "更新通用数据", 73 "通用数据表" + tableName + "更新成功"); 74 MessageBox.Show("更新数据库成功"); 75 } 76 else 77 { 78 LogHelp.writeLog(FrmMain.username, "更新通用数据", 79 "通用数据表" + tableName + "更新失败"); 80 MessageBox.Show("数据库没有更新"); 81 } 82 }


 
     这个函数功能相对复杂，因为涉及到级联更新操作，不是使用的触发器功能，因为不能使用触发器，他们的关联情况是根据ID字段部分内容进行关联的，可能是前几位不等。所以实现这个功能就相对复杂，我采用的方式是对这些关联关系我通过一张数据表来维护，通过这张数据表就很轻松查出有关联关系的表的所有内容，根据这些内容就可以做到级联更新了，不过级联更新都是采用的事务操作来保证数据的一致性，级联更新在单独一个函数中实现，函数代码如下：


1 /// <summary> 2 /// 更新于相关的表 3 /// </summary> 4 /// <param name="cmd">带事务的命令</param> 5 private void UpdateRelationTable(OracleCommand cmd) 6 { 7 //处理有ID改变的情况 8 SqlHelper sh = new SqlHelper(); 9 string sql = string.Empty; 10 if (bIdChange) 11 { 12 //更新相关的表 13 for (int i = 0; i < oldIdList.Count; ++i ) 14 { 15 //1.查询数据字典找到所有需要更新的表 16 //string strTable = tableName.Substring(tableName.IndexOf('.')+1); 17 sql = "select second,bits from jcsjk_relation where first='" 18 + tableName + "'"; 19 OracleDataReader odr = sh.ReturnDataReader(sql); 20 while (odr.Read()) 21 { 22 //得到ID关联的位数 23 int bits = int.Parse(odr[1].ToString()); 24 //得到完整的表名称，包括表的拥有者 25 string strTemp = odr[0].ToString(); 26 //得到被改变的ID的前bits位 27 string strOldId = oldIdList.ToString().Substring(0, bits); 28 //查询需要更新的相关ID 29 string strAll = odr[0].ToString(); 30 sql = "select id from " + strAll + " where id like '" + strOldId + "%'"; 31 OracleDataReader odr1 = sh.ReturnDataReader(sql); 32 while (odr1.Read()) 33 { 34 //根据前bits位构建新的ID 35 string strNewId = newIdList.ToString().Substring(0, bits); 36 strNewId += odr1[0].ToString().Substring(bits); 37 //根据查询出来的旧ID更新ID 38 sql = "update " + strTemp + " set id='" + strNewId 39 + "' where id ='" + odr1[0].ToString() + "'"; 40 cmd.CommandText = sql; 41 cmd.ExecuteNonQuery(); 42 } 43 } 44 } 45 } 46 //处理有ID删除的情况 47 if (bIdDel) 48 { 49 foreach (string str in delIdList) 50 { 51 //查询和删除ID相关的表并执行事务删除 52 //string strTable = tableName.Substring(tableName.IndexOf('.') + 1); 53 sql = "select second,bits from jcsjk_relation where first='" 54 + tableName + "'"; 55 OracleDataReader odr = sh.ReturnDataReader(sql); 56 while (odr.Read()) 57 { 58 string strTemp = odr[0].ToString(); 59 string strOldId = str.Substring(0, int.Parse(odr[1].ToString())); 60 sql = "delete from " + strTemp + " where id like '" + strOldId + "%'"; 61 cmd.CommandText = sql; 62 cmd.ExecuteNonQuery(); 63 } 64 } 65 } 66 }


 
    保存按钮事件的功能除了同步改变的数据到数据库以外，还会对具体的操作记录日志并写入数据库日志表中，这个日志主要用于多台数据库服务器的同步操作。
5.绑定数据的控件数据单元的值发生变化产生时的响应函数代码如下：


1 /// <summary> 2 /// 如果ID这一列的值有改变就保存改变后的值，原来的值在开始编辑事件中保存，如果值没有改变，将在编辑结束 3 /// 删除掉保存的原理的ID值，以保证原来的ID值与改变后的ID值一一对应，方便级联更新和删除 4 /// </summary> 5 /// <param name="sender"></param> 6 /// <param name="e"></param> 7 private void dataGridViewX1_CellValueChanged(object sender, DataGridViewCellEventArgs e) 8 { 9 if (dataGridViewX1.Columns[e.ColumnIndex].HeaderText == "ID") 10 { 11 if (selectedNodeText == "DZYJ_JCSJK.city_code" || selectedNodeText == "DZYJ_JCSJK.county_code" 12 || selectedNodeText == "DZYJ_JCSJK.town_code" || selectedNodeText == "DZYJ_JCSJK.village_code" 13 || selectedNodeText == "DZYJ_JCSJK.enterprise_code") 14 { 15 bIdChange = true; 16 //保存新ID 17 newIdList.Add(dataGridViewX1.Rows[e.RowIndex].Cells[e.ColumnIndex].Value.ToString()); 18 bCellValueChange = true; 19 } 20 } 21 isChanged = true; 22 saveBtn.Enabled = true; 23 }


 

 6.当用户在输入数据非法是执行如下函数；


1 /// <summary> 2 /// 提示用户录入数据非法 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void dataGridViewX1_DataError(object sender, DataGridViewDataErrorEventArgs e) 7 { 8 labelX6.Text = "数据录入格式不正确"; 9 }


 

 7.导出数据到excel或word：


1 /// <summary> 2 /// 导出数据到excel和word 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void exportBtn_Click(object sender, EventArgs e) 7 { 8 //选择导出的类型，excel或word 9 FrmSelectExpType fset = new FrmSelectExpType(); 10 fset.ShowDialog(); 11 12 if (fset.isGon) 13 { 14 //根据选择的类型执行相应的导出功能 15 if (fset.type == 0) 16 { 17 //调用通用工具类的静态函数导出为word 18 CommonTools.ExportDataGridViewToWord(dataGridViewX1); 19 } 20 else 21 { 22 ////调用通用工具类的静态函数导出为word 23 CommonTools.DataToExcel(dataGridViewX1); 24 MessageBox.Show("导出数据完成!"); 25 } 26 } 27 }


 
 
8.滚动显示数据表的所有数据：


1 /// <summary> 2 /// 显示所有的数据，可以滚动 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void showAllBtn_Click(object sender, EventArgs e) 7 { 8 dataGridViewX1.ScrollBars = ScrollBars.Both; 9 try 10 { 11 dataGridViewX1.FirstDisplayedScrollingRowIndex = 0; 12 } 13 catch (ArgumentOutOfRangeException) 14 { 15 16 } 17 }


 

 9.分页显示函数功能：


1 /// <summary> 2 /// 分页就是通过设置第一个显示的行来实现 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void comboBoxEx1_SelectedValueChanged(object sender, EventArgs e) 7 { 8 try 9 { 10 dataGridViewX1.FirstDisplayedScrollingRowIndex = comboBoxEx1.SelectedIndex * 10; 11 } 12 catch (ArgumentOutOfRangeException) 13 { 14 15 } 16 }


 

 10.导入excel的数据到控件中（DataGridView控件）：


1 /// <summary> 2 /// 导入一个选择的excel文件到DataGridView中 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void importBtn_Click(object sender, EventArgs e) 7 { 8 //打开一个文件选择框 9 OpenFileDialog ofd = new OpenFileDialog(); 10 ofd.Title = "Excel文件"; 11 ofd.FileName = ""; 12 //为了获取特定的系统文件夹，可以使用System.Environment类的静态方法GetFolderPath()。 13 //该方法接受一个Environment.SpecialFolder枚举，其中可以定义要返回路径的哪个系统目录 14 ofd.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); 15 ofd.Filter = "Excel文件(*.xls)|*.xls"; 16 17 //文件有效性验证ValidateNames，验证用户输入是否是一个有效的Windows文件名 18 ofd.ValidateNames = true; 19 ofd.CheckFileExists = true; //验证路径有效性 20 ofd.CheckPathExists = true; //验证文件有效性 21 if (ofd.ShowDialog() == DialogResult.Cancel) 22 { 23 return; 24 } 25 26 if (ofd.FileName == "") 27 { 28 MessageBox.Show("没有选择Excel文件！无法进行数据导入"); 29 return; 30 } 31 //调用导入数据方法 32 CommonTools.EcxelToDataGridView(ofd.FileName, dataGridViewX1); 33 MessageBox.Show("导入数据完成!"); 34 }


 

 11.浏览地图功能实现：


1 /// <summary> 2 /// 浏览地图 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void mapBrowseBtn_Click(object sender, EventArgs e) 7 { 8 Node tn = DataManagerTree.FindNodeByText(selectedNodeText); 9 10 string tabName = "地图浏览"; 11 if (!((FrmMain)this.MdiParent).IsOpenTab(tabName)) 12 { 13 fsl = new FrmShowLayer(); 14 15 fsl.MdiParent = MdiParent; 16 fsl.WindowState = FormWindowState.Maximized; 17 this.WindowState = FormWindowState.Normal; 18 fsl.Show(); 19 20 } 21 /* 22 if (fsl == null) 23 { 24 fsl = new FrmShowLayer(); 25 } 26 fsl.WindowState = FormWindowState.Maximized; 27 fsl.Show();*/ 28 if (tn.Parent.Text != "属性表") 29 { 30 fsl.AddLayerToMapCtl(tn.Text.ToUpper(), true); 31 } 32 }


 

 12.树形节点选中时功能的处理，不同节点有不同的处理方式（同一层是同样的功能，只是处理的数据不同而已）：


1 /// <summary> 2 /// 选中一个树节点的时候对应不同层次做不同处理，可以显示选中的数据集， 3 /// 选中一个表就在DataGridView中显示表的数据 4 /// </summary> 5 /// <param name="sender"></param> 6 /// <param name="e"></param> 7 private void DataManagerTree_AfterNodeSelect(object sender, AdvTreeNodeEventArgs e) 8 { 9 //DataGridView中没有数据时禁止导入导出和浏览地图功能 10 mapBrowseBtn.Enabled = false; 11 importBtn.Enabled = false; 12 exportBtn.Enabled = false; 13 addBtn.Enabled = false; 14 modifyBtn.Enabled = false; 15 deleteBtn.Enabled = false; 16 showAllBtn.Enabled = false; 17 18 Node tn = new Node(); 19 20 tn = e.Node; 21 selectedNodeText = tn.Text; 22 23 switch (tn.Level) 24 { 25 case 1: 26 labelX3.Text = tn.Text; 27 break; 28 case 2: 29 //使能功能按钮 30 addBtn.Enabled = true; 31 modifyBtn.Enabled = true; 32 deleteBtn.Enabled = true; 33 showAllBtn.Enabled = true; 34 isChanged = false; 35 bIdDel = false; 36 bIdChange = false; 37 dataGridViewX1.ReadOnly = true; 38 dataGridViewX1.AllowUserToAddRows = false; 39 dataGridViewX1.AllowUserToDeleteRows = false; 40 41 delIdList.Clear(); 42 newIdList.Clear(); 43 oldIdList.Clear(); 44 45 labelX3.Text = e.Node.Parent.Text; 46 labelX4.Text = ""; 47 labelX4.Text = "当前数据表： " + tn.Text; 48 49 SqlHelper sh = new SqlHelper(); 50 51 string[] first = tn.Text.Split('.'); 52 string sql = "select column_name,data_type from all_tab_columns where table_name='" 53 + first[1].ToUpper() + "' and owner='" + first[0].ToUpper() + "'"; 54 55 if (sh.GetRecordCount(sql) <= 0) 56 { 57 MessageBox.Show("数据表不存在!"); 58 return; 59 } 60 tableName = tn.Text; 61 OracleDataReader odr = sh.ReturnDataReader(sql); 62 //动态构建显示的sql语句，填充的字段 63 sql = "select "; 64 while (odr.Read()) 65 { 66 //当DataGridView中有数据时就可以导入导出了 67 importBtn.Enabled = true; 68 exportBtn.Enabled = true; 69 70 if (odr[0].ToString() == "SHAPE") 71 { 72 //当DataGridView中有空间数据时就可以浏览地图了 73 mapBrowseBtn.Enabled = true; 74 //DataGridView不能显示Shape字段 75 continue; 76 } 77 //如果数据类型是BLOB就不加载 78 if (odr[1].ToString() == "BLOB") 79 { 80 continue; 81 } 82 sql += odr[0].ToString() + ","; 83 } 84 //移除最后一个逗号 85 sql = sql.Remove(sql.LastIndexOf(',')); 86 sql += " from " + tableName; 87 88 if (Connection.State != ConnectionState.Open) 89 { 90 Connection.Open(); 91 } 92 //构建数据适配器为了修改数据，绑定的数据表必须有主键才能修改 93 da = new OracleDataAdapter(sql, Connection); 94 builder = new OracleCommandBuilder(da); 95 ds = new DataSet(); 96 97 try 98 { 99 da.Fill(ds, tableName); 100 dataGridViewX1.DataSource = null; 101 dataGridViewX1.DataSource = ds.Tables[0]; 102 } 103 catch (System.Exception ex) 104 { 105 MessageBox.Show(ex.Message); 106 } 107 108 //以下是实现分页显示 109 int intMod, dgr; 110 //先让垂直滚动条消失 111 dataGridViewX1.ScrollBars = ScrollBars.Horizontal; 112 //取出DGV的行数，为什么要减一是因为它总是多出一行给你编辑的所以那行也占用一行的空间 113 dgr = dataGridViewX1.RowCount - 1; 114 //进行取模 115 if (dgr % 10 == 0) 116 { 117 intMod = 0; 118 } 119 else 120 { 121 intMod = 1; 122 } 123 //主要时这个for循环将表一共分为几页添加到comboBox 124 comboBoxEx1.Items.Clear(); 125 for (int i = 1; i <= dgr / 10 + intMod; i++) 126 { 127 comboBoxEx1.Items.Add("第" + i + "页"); 128 } 129 //默认选中第一个 130 if (comboBoxEx1.Items.Count > 0) 131 { 132 comboBoxEx1.SelectedIndex = 0; 133 } 134 break; 135 default: 136 break; 137 } 138 }


 

 13.树形节点被展开时执行的相应功能实现如下：


1 /// <summary> 2 /// 节点展开以后显示下层节点 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void DataManagerTree_AfterExpand(object sender, AdvTreeNodeEventArgs e) 7 { 8 Node tn = e.Node; 9 string sql; 10 SqlHelper sh = new SqlHelper(); 11 OracleDataReader odr; 12 13 switch (tn.Level) 14 { 15 case 0: 16 tn.Nodes.Clear(); 17 sql = "select name from jcsjk_element where category='矢量数据'"; 18 odr = sh.ReturnDataReader(sql); 19 20 while (odr.Read()) 21 { 22 Node t = new Node(); 23 t.Text = odr[0].ToString(); 24 tn.Nodes.Add(t); 25 t.Nodes.Add(new Node()); 26 } 27 break; 28 case 1: 29 tn.Nodes.Clear(); 30 sql = "select table_name from jcsjk_layer l,jcsjk_element e where l.pid=e.id and e.name = '" 31 + tn.Text + "' and e.category='矢量数据'"; 32 odr = sh.ReturnDataReader(sql); 33 34 while (odr.Read()) 35 { 36 Node t = new Node(); 37 t.Text = odr[0].ToString(); 38 39 tn.Nodes.Add(t); 40 } 41 break; 42 default: 43 break; 44 } 45 }


 

 14.开始编辑控件数据的时候执行的函数功能实现如下：


1 /// <summary> 2 /// 开始编辑事件，如果编辑的是ID列就保存原来的ID 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void dataGridViewX1_CellBeginEdit(object sender, DataGridViewCellCancelEventArgs e) 7 { 8 if (dataGridViewX1.Columns[e.ColumnIndex].HeaderText == "ID") 9 { 10 if (selectedNodeText == "DZYJ_JCSJK.city_code" || selectedNodeText == "DZYJ_JCSJK.county_code" 11 || selectedNodeText == "DZYJ_JCSJK.town_code" || 12 selectedNodeText == "DZYJ_JCSJK.village_code" || selectedNodeText == "DZYJ_JCSJK.enterprise_code") 13 { 14 if (oldIdList == null) 15 { 16 oldIdList = new ArrayList(); 17 } 18 //保存旧ID 19 if (dataGridViewX1.Rows[e.RowIndex].Cells[e.ColumnIndex].Value.ToString() != "") 20 { 21 oldIdList.Add(dataGridViewX1.Rows[e.RowIndex].Cells[e.ColumnIndex].Value.ToString()); 22 } 23 } 24 } 25 }


 

 15.结束编辑控件数据的时候执行的函数功能实现如下：


        /// <summary> /// 编辑结束事件，如果ID值没有改变就删除原来保存的 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void dataGridViewX1_CellEndEdit(object sender, DataGridViewCellEventArgs e)
        { if (bCellValueChange)
            {
                bCellValueChange = false;
            } else { if (dataGridViewX1.Columns[e.ColumnIndex].HeaderText == "ID")
                { if (selectedNodeText == "DZYJ_JCSJK.city_code" || selectedNodeText == "DZYJ_JCSJK.county_code" || selectedNodeText == "DZYJ_JCSJK.town_code" ||
                        selectedNodeText == "DZYJ_JCSJK.village_code" || selectedNodeText == "DZYJ_JCSJK.enterprise_code")
                    { if (dataGridViewX1.Rows[e.RowIndex].Cells[e.ColumnIndex] != null)
                        {
                            oldIdList.Remove(dataGridViewX1.Rows[e.RowIndex].Cells[e.ColumnIndex].Value.ToString());
                        }
                    }
                }
            }
        }


     到此整个同样数据管理模块的功能已经实现，这里需要强调一点的是，当在判断对于的属性数据是否对应有相应的空间数据时就是判断对于的表结构是否有“Shape”字段，空间数据里面还涉及到很多概念以后在介绍管理空间数据时会详细介绍。还有一点就是上面实现图层的可视化显示（地图）后面会详细介绍，至于word和excel的导入导出功能是在一个通过用的工具类中实现，以方便整个程序中都可以使用，日志的写入也是专门的日志帮助类实现。