AutoCAD中的扩展字典及扩展记录（C#）

在学习CAD扩展记录的过程中，遇到了一些问题，也积累了一些经验，现在给大家分享一些我的学习心得。在学习扩展字典之前需要读者了解cad的组码，也就是DxfCode。感兴趣的也可以了解一下扩展数据的相关内容（后面有时间也会分享一下，因为扩展数据、扩展字典和DxfCode组码之间有密切的关系）。

一个CAD对象只能拥有一个扩展字典，而扩展字典下面可以包含多个扩展记录。打个比方，可以这么理解，如果扩展字典相当于excel文件，那么一个扩展记录就相当于excel中的一个表单sheet对象，扩展记录中存储的数据就相当于表单sheet中的数据。

使用扩展记录可以向对象中保存一些属性数据，以便后续提取之用，这是很有用的。比如说可以向一个多段线（代表一根管线，或是其他）中存储一些施工方面的数据信息，例如施工标段、桩号范围、施工完成时间等，以后再打开图的时候，就知道这段管线是哪个施工单位施工的，什么时间完成的等等，便于查看和统计。CAD程序自身的属性对话框是无法记录这些信息的。

向对象添加扩展记录一般分为三个步骤：

1 将添加的数据构成一个类

2 编写扩展方法，包括扩展记录的添加、读取、删除、修改

3 调用扩展方法进行操作

界面如下：

下面列出主要的代码

1 将需要添加的数据构成一个类，主要包括施工标段、信息、桩号、完成时间等属性

 public class XDataClass
    {
        public string BiaoDuan { get; set; }//施工标段
        public string Information { get; set; }//附加到对象上的信息
        public double StationStart { get; set; }//起始桩号
        public double StationEnd { get; set; }//终止桩号
        public double Length { get; private set; }//长度
        public DateTime OverTime { get; set; }//完成时间
        public string XRecordName { get; set; } //扩展记录名称
        public XDataClass() { }
        public XDataClass(string xrecordName)
        {
            XRecordName = xrecordName;
        }
        /// <summary>
        /// 将扩展数据实体类转化成typevaluelist类型
        /// </summary>
        /// <param name="xdataClass"></param>
        /// <returns></returns>
        public static TypedValueList ClassToTypeValueList(XDataClass xdataClass)
        {
            TypedValueList tvList = new TypedValueList
            {
                {DxfCode.Text, xdataClass.BiaoDuan },
                {DxfCode.Text, xdataClass.Information },
                {DxfCode .Real ,xdataClass.StationStart  },
                {DxfCode.Real ,xdataClass .StationEnd  },
                {DxfCode.Text ,xdataClass .OverTime .ToString ("d") },
                {DxfCode.Text ,xdataClass.XRecordName  },
            }; 
            return tvList;
        }
        /// <summary>
        /// 将typevaluelist类型的数据转换成实体类
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static XDataClass TypeValueListToClass(TypedValueList list)
        {
            XDataClass xdataClass = new XDataClass()
            {
                BiaoDuan = list[0].Value.ToString(),
                Information = list[1].Value.ToString(),
                StationStart = Convert.ToDouble(list[2].Value),
                StationEnd = Convert.ToDouble(list[3].Value),
                OverTime = Convert.ToDateTime(list[4].Value),
                XRecordName = list[5].Value.ToString(),
                Length = Math.Abs(Convert.ToDouble(list[3].Value) - Convert.ToDouble(list[2].Value))
            };
            return xdataClass;
        }
    }

2  编写扩展方法，包括扩展记录的添加、读取、删除、修改

#region 对象的扩展记录的添加、删除、修改
        /// <summary>
        ///  添加扩展记录，如果没有扩展字典，那就创建扩展字典
        /// </summary>
        /// <param name="objId">对象的objectid</param>
        /// <param name="xRecordSearchKey">扩展记录名称</param>
        /// <param name="values">扩展记录的内容</param>
        /// <returns></returns>
        public static bool AddXRecordToObj(this ObjectId objId, string xRecordSearchKey, TypedValueList values)
        {
            //添加扩展记录之前，先创建对象的扩展字典
            DBObject obj = objId.GetObject(OpenMode.ForRead);//以读的方式打开
            if (obj.ExtensionDictionary.IsNull)//如果对象无扩展字典，那就给创建
            {
                obj.UpgradeOpen();//切换对象为写的状态
                obj.CreateExtensionDictionary();//为对象创建扩展字典，一个对象只能拥有一个扩展字典
                obj.DowngradeOpen();//将对象切换为读的状态
            }
            //打开对象的扩展字典
            DBDictionary dict = obj.ExtensionDictionary.GetObject(OpenMode.ForRead) as DBDictionary;
            //如果扩展字典中已包含指定的扩展记录对象  
            if (dict.Contains(xRecordSearchKey))
            {
                 return false;//如果包含有指定的扩展记录，那就退出
            }
            else //若没有包含扩展记录，则创建一个
            {
                Xrecord xrec = new Xrecord();//为对象创建一个扩展记录 
                xrec.Data = values;//指定扩展记录的内容，这里用到了自定义类型转换，TypedValueList-->ResultBuffer
                dict.UpgradeOpen();//将扩展字典切换为写的状态，以便添加一个扩展记录
                ObjectId xrecId = dict.SetAt(xRecordSearchKey, xrec);//在扩展字典中加入新建的扩展记录，并指定它的搜索关键字
                objId.Database.TransactionManager.AddNewlyCreatedDBObject(xrec, true);
                dict.DowngradeOpen();//将扩展字典切换为读的状态
                return true; 
            }
        }

        /// <summary>
        /// 用于替换扩展字典中的整个一条扩展记录
        /// </summary>
        /// <param name="objId">对象id</param>
        /// <param name="xRecordSearchKey">扩展记录的名称</param>
        /// <param name="values">扩展记录的内容</param>
        public static bool ModObjXrecord(this ObjectId objId, string xRecordSearchKey, TypedValueList values)
        {
            DBObject obj = objId.GetObject(OpenMode.ForRead);//以读的方式打开对象
            ObjectId dictId = obj.ExtensionDictionary;//获取对象的扩展字典id
            if (dictId.IsNull)
            {
                return false;//若对象没有扩展字典，则返回 
            }
            //如果对象有扩展字典，则以读的方式打开
            DBDictionary dict = dictId.GetObject(OpenMode.ForRead) as DBDictionary;
            if (!dict.Contains(xRecordSearchKey))
            {
                return false;//如果扩展字典中没有包含指定关键字的扩展记录，则返回 ；
            }
            ObjectId xrecordId = dict.GetAt(xRecordSearchKey);//获取扩展记录的id
            Xrecord xrecord = xrecordId.GetObject(OpenMode.ForWrite) as Xrecord;
            xrecord.Data = values;//覆盖原来的数据，因为values有了新的指向
            xrecord.DowngradeOpen();//将扩展记录切换为读的状态
            return true;
        }

        /// <summary>
        /// 获取对象的扩展字典中的扩展记录
        /// </summary>
        /// <param name="objId">对象的id</param>
        /// <param name="xRecordSearchKey">扩展记录名称</param>
        /// <returns></returns>
        public static TypedValueList GetObjXrecord(this ObjectId objId, string xRecordSearchKey)
        {
            DBObject obj = objId.GetObject(OpenMode.ForRead);//以读的方式打开对象
            ObjectId dictId = obj.ExtensionDictionary;//获取对象的扩展字典的id
            if (dictId.IsNull)
            {
                //MessageBox.Show("没有扩展字典");
                return null;//若对象没有扩展字典，则返回null
            }
            DBDictionary dict = dictId.GetObject(OpenMode.ForRead) as DBDictionary;//获取对象的扩展字典
            if (!dict.Contains(xRecordSearchKey))
            {
                return null;//如果扩展字典中没有包含指定关键字的扩展记录，则返回null；
            }
            //先要获取对象的扩展字典或图形中的有名对象字典，然后才能在字典中获取要查询的扩展记录
            ObjectId xrecordId = dict.GetAt(xRecordSearchKey);//获取扩展记录对象的id
            Xrecord xrecord = xrecordId.GetObject(OpenMode.ForRead) as Xrecord;//根据id获取扩展记录对象
            TypedValueList values = xrecord.Data;
            return values;//values 数组应该是有先后顺序的
        }

        /// <summary>
        ///用于删除对象扩展字典中的指定的扩展记录
        /// </summary>
        /// <param name="objId">对象id</param>
        /// <param name="xRecordSearchKey"> 扩展记录名称</param>
        public static bool DelObjXrecord(this ObjectId objId, string xRecordSearchKey)
        {
            DBObject obj = objId.GetObject(OpenMode.ForRead);//以读的方式打开对象
            ObjectId dictId = obj.ExtensionDictionary;//获取对象的扩展字典id
            if (dictId.IsNull)
            {
                return false;//若对象没有扩展字典，则返回 
            }
            //如果对象有扩展字典，则以读的方式打开
            DBDictionary dict = dictId.GetObject(OpenMode.ForRead) as DBDictionary;
            if (dict.Contains(xRecordSearchKey))//如果扩展字典中包含指定关键字的扩展记录，则删除；
            {
                dict.UpgradeOpen();//切换为写的状态
                dict.Remove(xRecordSearchKey);//删除扩展记录
                dict.DowngradeOpen();//切换为读的状态
            }
            return true;
        }
        
        /// <summary>
        /// 删除对象的扩展字典下的所有的扩展记录
        /// 2018年4月7日09:44:12
        /// </summary>
        /// <param name="objId"></param>
        public static bool DelObjAllXrecords(this ObjectId objId)
        {
            DBObject obj = objId.GetObject(OpenMode.ForRead);//以读的方式打开对象
            ObjectId dictId = obj.ExtensionDictionary;//获取对象的扩展字典id
            if (dictId.IsNull)
            {
                return false;//若对象没有扩展字典，则返回 
            }
            //如果对象有扩展字典，则以读的方式打开
            DBDictionary dict = dictId.GetObject(OpenMode.ForWrite) as DBDictionary;
            //获取扩展字典下的所有扩展记录名称集合 Keys 
133             List<string> listKeys = new List<string>();
            foreach (var item in dict)//获取扩展字典中的所有条目，也就是所有的扩展记录的key
            {
                listKeys.Add(item.Key);
            }
            foreach (var key in listKeys)//根据key,删除扩展字典中的每一个条目（也就是扩展记录）
            {
                dict.Remove(key);
            }
            dict.DowngradeOpen();//切换为读的状态 
            return true;
        }


        /// <summary>
        /// 删除对象的扩展字典，因为每个对象只能拥有一个扩展字典，所以给定对象的objectID就好了
        ///  2018年4月7日09:17:44 
        /// </summary>
        /// <param name="objId"></param>
        public static bool DeleteObjExtensionDictionary(this ObjectId objId)
        {
            DBObject obj = objId.GetObject(OpenMode.ForRead);//以读的方式打开对象
            ObjectId dictId = obj.ExtensionDictionary;//获取对象的扩展字典的ID
            if (dictId.IsNull)
            {
                return false;    //没有扩展字典
            }
            //有扩展字典 161             obj.UpgradeOpen();//切换对象为写的状态
162             objId.DelObjAllXrecords(); //调用上面的方法，在删除扩展字典之前要先删除扩展记录
            obj.ReleaseExtensionDictionary();//移除对象的扩展字典，一个对象只能拥有一个扩展字典
            obj.DowngradeOpen();//将对象切换为读的状态 
            return true;
        }
        #endregion

3调用扩展方法

  a 添加扩展记录

 //btn  添加扩展记录
        XDataClass PipeXdataClass = new XDataClass(Enum_XRcordName.pipe_whlkx.ToString());
        ObjectId selectedObjId = ObjectId.Null;
        private void btnAddXData_Click(object sender, EventArgs e)
        {
            if (CheckValue() == false)
            {
                return;
            }
            _instance.Hide();
            Document doc = AcadApp.DocumentManager.MdiActiveDocument;
            Database db = doc.Database;
            Editor ed = doc.Editor; 
            PromptEntityResult entityResult = ed.GetEntity("
请选择一个多段线对象");//单个拾取对象 
            if (entityResult.Status != PromptStatus.OK)
            {
                _instance.Show();
                return;
            }
            GetDataFromControls(PipeXdataClass);//私有函数，将控件中的数据填充到实体类中
            //获取对象的ID
            ObjectId objId = entityResult.ObjectId; 
            bool result = false;
            using (DocumentLock docLock = doc.LockDocument())
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //将xdataCalss类型的数据转换成一个typevalue型的列表
                TypedValueList values = XDataClass.ClassToTypeValueList(PipeXdataClass);
                result = objId.AddXRecordToObj(PipeXdataClass.XRecordName, values);
                trans.Commit();
            }
            if (result)
            {
                ed.WriteMessage("
对象的扩展数据添加成功！");
            }
            else
            {
                ed.WriteMessage("
对象已经有扩展数据");
            }
            _instance.Show();
        }

  

  b 读取扩展记录 

//btn 读取扩展记录
        private void btnReadXData_Click(object sender, EventArgs e)
        {
            _instance.Hide();
            ClearContent();//清空控件中的内容
            Document doc = AcadApp.DocumentManager.MdiActiveDocument;
            Database db = doc.Database;
            Editor ed = doc.Editor;
            //开始事务处理
            using (DocumentLock docLock = doc.LockDocument())
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                PromptEntityResult entityResult = ed.GetEntity("
请选择一个对象");//拾取单个对象
                if (entityResult.Status != PromptStatus.OK)
                {
                    ed.WriteMessage("
取消了选择");
                    _instance.Show();
                    return;
                }
                //获取对象的ID
                ObjectId objId = entityResult.ObjectId;
                TypedValueList list = objId.GetObjXrecord(PipeXdataClass.XRecordName);
                if (list is null)
                {
                    ed.WriteMessage("
该对象没有扩展记录");
                    _instance.Show();
                    return;
                }
                if (list.Count <= 0)
                {
                    ed.WriteMessage("
有扩展记录，但是记录为空");
                    _instance.Show();
                    return;
                }
                else
                {
                    PipeXdataClass = XDataClass.TypeValueListToClass(list);
                    SetDataToControls(PipeXdataClass);//向控件中填充数据
                    ed.WriteMessage("
对象扩展数据读取成功");
                    selectedObjId = objId;
                }
            }
            _instance.Show();
        }

  c 删除扩展记录

        //btn 删除
        private void btnDeleteXData_Click(object sender, EventArgs e)
        {
            _instance.Hide();
            Document doc = AcadApp.DocumentManager.MdiActiveDocument;
            Database db = doc.Database;
            Editor ed = doc.Editor;
            //开始事务处理
            using (DocumentLock docLock = doc.LockDocument())
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                PromptSelectionResult ss1 = ed.GetSelection();//框选对象
                if (ss1.Status != PromptStatus.OK)
                {
                    ed.WriteMessage("
取消了选择");
                    _instance.Show();
                    return;
                }
                //获取对象的ID
                List<ObjectId> listObjIds = ss1.Value.GetObjectIds().ToList();
                int count = 0;
                listObjIds.ForEach(objId =>
                {
                    if (objId.DeleteObjExtensionDictionary())
                    {
                        ed.WriteMessage("
删除成功");
                        count++;
                    }
                });
                //ObjectId objId = entityResult.ObjectId;
                //2018年4月7日09:50:35，经验证，必须先删除扩展字典下的所有的扩展记录，才能删除对象的扩展字典
                //否则会出现错误：eContainerNotEmpty ，容器不为空
                //objId.DelObjAllXrecords();
                //objId.DeleteObjExtensionDictionary();
                trans.Commit();
                ed.WriteMessage("
操作完成，总共删除{0}个扩展记录", count);
            } 
            _instance.Show();
        }

 修改扩展记录可以自己写一下，比较简单。

  下面给出一张图关于扩展字典和扩展记录的示意图，便于理解之间的关系。