ArcGis开发笔记C#

关于persistence
persistence是将对象的当前状态持久的保存在文件、磁盘等存储媒介的过程。

在ArcGIS 中persistence被用来保存文档和模板的当前状态。

通过ArcGIS的UI，可以更改地图文档的众多属性、参数，比如渲染器。

当地图保存关闭后，渲染器的实例会释放。

当再次打开地图，由于persistence的作用，渲染器会根据保存的状态做预设置，看到和先前一样的状态。

Structured storage, compound files, documents, and streams
地图文档的保存采用结构化存储技术，结构化存储是实现persistence的一种方式。

结构化存储中，采用混合文件模型，文件既包含存储对象又包含流对象，存储对象提供结构并可以包含其他的存储对象和流对象，而流对象提供存储功能可以存储基于内部结构的任意类型数据。

当流被重新打开时，新对象从流中获取状态信息进行初始化，重新创建之前对象的状态。

这样，一个单独的混合文件可以当作一个微型文件系统，可以被多个文件指针访问。

结构化存储的优点有：文件渐进式读写、文件结构标准化、容量大。

ArcGIS采用结构化存储保持程序所有对象的当前状态，结构化存储只能用于非GIS数据。

混合文档结构
ArcGIS采用混合文档结构保存文档（map文档、globe文档）、模板（map模板、globe 模板）。

当文档被保存，所有文档的对象都保存在混合文档的流中。

例如，一个map文档单击“保存”后，MxApplication创建一个流绑定到现存的.mxd文件，让后将文档信息保存到流中。

ArcMap可以保存多个项：
1、地图集——图层、符号、图形、当前范围、空间引用、渲染器等
2、纸面布局、地图框、地图周边等
3、TOC状态
4、工具栏的显示状态
5、当前数据窗口、类型、位置和内容
persistence类
当对象需要保存自己的状态，它必须将自己的成员变量写入流中。

当对象中存在引用类型变量，并且引用的对象支持persistence，则要求成员对象自己保存当前状态。

对象及成员对象persist过程：
ObjectStreams
在persistence过程中，多个引用可能指向同一个对象，这样对象会被多次复制，多次独立的保存在流中，ArcObjects引入ObjectStreams解决此类问题。

当ArcObjects对象进行persistence时，创建stream的同时，创建ObjectStream并与stream关联。

ObjectStream中保存了进行persist的对象列表。

当对象第一次被persist时，采用一般的方式进行，当对象第二次被persist时，ObjectStream确保对象不被第二次persist，而是保存该对象的引用。

实现persistence类
创建persistable类，需要实现IPersist接口和IPersistStream接口（或IPers istVariant 接口）。

IPersistStream接口和IPersistVariant接口的一些功能：
1、获取对象ID IPersistStream.GetClassID IPersistVariant.ID
2、将对象保存到流IPersistStream.Save IPersistVariant.Save
3、从流获取数据IPersistStream.Load IPersistVariant.Load
实现IPersistVariant接口
C#中实现任意类的完美克隆
虽然在现实世界中的克隆课题是有争议的, 在.NET世界使用它却足够安全, 难道不是吗?
为实现一个类你究竟有多少次要实现ICloneable接口, 而且每一次都写相同的代码，或为每个类写特定的代码。

而且,当你的类加入一个新的字段时，往往会忘记更新这个新字段的克隆方法。

如果我没说错的话，这种时候往往会带来恼人的bugs。

这是我的类得以存在的原因。

藉由反射机制的小小帮助，我建立了一个用缺省行为实现了ICloneable接口的抽象类。

现在或许你正在问自己: 什么是缺省行为? 那么我很高兴你这样询问。

克隆的缺省行为，是采用以下的规则来克隆类中的每一个字段：
查看一下类中的每一个字段是否支持ICloneable接口
如果某字段不支持ICloneable接口，那么该字段将以常规方式处理。

这意味着，如果该字段是一个值类型，那么该值被拷贝；如果该字段是一个引用类型，克隆的字段将指向同一个对象。

如果该字段支持ICloneable接口，我们将使用其本身的Clone方法对其进行克隆。

如果该字段支持IEnumerable接口，我们需要检查他是否支持IList 或IDictionary 接口。

如果支持，那么我们迭代该集件，并且查看集合的每一项是否支持Cloneable接口。

如何使用
让你的类支持Icloneable接口所要做的就是，将你的类继承自如下所述的BaseObject类：
public class MyClass : BaseObject
{
public string myStr ="test";
public int id;
}
public class MyContainer : BaseObject
{
public string name = "test2";
public MyClass[] myArray= new MyClass[5];
public class MyContainer()
{
for(int i=0 ; i<5 ; i++)
{
this.myArray[I] = new MyClass();
}
}
}
现在在Main方法中加入如下代码：
static void Main(string[] args)
{
MyContainer con1 = new MyContainer();
MyContainer con2 = (MyContainer)con1.Clone();
con2.myArray[0].id = 5;
}
当监测con2实例时，你将会看到MyClass实例的第一项已经变为5，而con1实例却没有改变。

这样你将明白加入到类中的任意支持ICloneable接口的字段将被同样地克隆。

而且，如果该字段支持IList 或 IDictionary 接口，克隆方法将侦测该字段，轮询所有项，并同样地试图对他们进行克隆。

BaseObject类的完整实现代码：
/// <summary>
/// BaseObject类是一个用来继承的抽象类。

/// 每一个由此类继承而来的类将自动支持克隆方法。

/// 该类实现了Icloneable接口，并且每个从该对象继承而来的对象都将同样地
/// 支持Icloneable接口。

/// </summary>
public abstract class BaseObject : ICloneable
{
/// <summary>
/// 克隆对象，并返回一个已克隆对象的引用
/// </summary>
/// <returns>引用新的克隆对象</returns>
public object Clone()
{
//首先我们建立指定类型的一个实例
object newObject = Activator.CreateInstance(this.GetType());
//我们取得新的类型实例的字段数组。

FieldInfo[] fields = newObject.GetType().GetFields();
int i = 0;
foreach (FieldInfo fi in this.GetType().GetFields())
{
//我们判断字段是否支持ICloneable接口。

Type ICloneType = fi.FieldType.GetInterface("ICloneable", true);
if (ICloneType != null)
{
//取得对象的Icloneable接口。

ICloneable IClone = (ICloneable)fi.GetValue(this);
//我们使用克隆方法给字段设定新值。

fields[i].SetValue(newObject, IClone.Clone());
}
else
{
// 如果该字段部支持Icloneable接口，直接设置即可。

fields[i].SetValue(newObject, fi.GetValue(this));
}
//现在我们检查该对象是否支持IEnumerable接口，如果支持，
//我们还需要枚举其所有项并检查他们是否支持IList 或IDictionary 接口。

Type IEnumerableType =
fi.FieldType.GetInterface("IEnumerable", true);
if (IEnumerableType != null)
{
//取得该字段的IEnumerable接口
IEnumerable IEnum = (IEnumerable)fi.GetValue(this);
Type IListType =
fields[i].FieldType.GetInterface("IList", true);
Type IDicType =
fields[i].FieldType.GetInterface("IDictionary", true);
int j = 0;
if (IListType != null)
{
//取得IList接口。

IList list = (IList)fields[i].GetValue(newObject);
foreach (object obj in IEnum)
{
//查看当前项是否支持支持ICloneable 接口。

ICloneType =
obj.GetType().GetInterface("ICloneable", true);
if (ICloneType != null)
{
//如果支持ICloneable 接口，
//我们用它李设置列表中的对象的克隆
ICloneable clone = (ICloneable)obj;
list[j] = clone.Clone();
}
//注意：如果列表中的项不支持ICloneable接口，那么
//在克隆列表的项将与原列表对应项相同
//（只要该类型是引用类型）
j++;
}
}
else if (IDicType != null)
{
//取得IDictionary 接口
IDictionary dic =
(IDictionary)fields[i].GetValue(newObject);
j = 0;
foreach (DictionaryEntry de in IEnum)
{
//查看当前项是否支持支持ICloneable 接口。

ICloneType = de.Value.GetType().
GetInterface("ICloneable", true);
if (ICloneType != null)
{
ICloneable clone = (ICloneable)de.Value; dic[de.Key] = clone.Clone();
}
j++;
}
}
}
i++;
}
return newObject;
}
}。