一个简单的powerdesigner模型（oom，pdm）分析器

　　由于工作需要，写了一个简单的模型分析器，源码：

    /// <summary>
    /// 通过Xml分析powerdesigner模型文件
    /// </summary>
    public class ModelAnalyserLinq : IModelAnalyser
    {  

        /// <summary>
        /// Xml命名空间管理
        /// </summary>
        XmlNamespaceManager nsmgr = null;

        /// <summary>
        /// 属性列表，记录字段
        /// </summary>
        List<ModelElement> listAtt = new List<ModelElement>();

        /// <summary>
        /// 单元列表：记录领域对象列表或者数据库表对象列表
        /// </summary>
        List<ModelElement> listUnit = new List<ModelElement>();

        /// <summary>
        /// 
        /// </summary>
        ModelType _mt = ModelType.Domain;

        /// <summary>
        /// 一个ModelAnalyser对应一个XElement root
        /// </summary>
        XElement root = null;

        public ModelAnalyserLinq(String fileName)
            : this(fileName, ModelType.Domain)
        {
            try
            {
                //执行linq检索(element) 
                var classesNodes  = from element in root.Descendants(Const.c + "Classes")
                          select element; 

                if (classesNodes.Count<XElement>() > 0)//说明存在类型，就是领域模型，数据库模型中不存在这个的
                {
                    _mt = ModelType.Domain;
                }
                else
                {
                    var tablesNodes = from element in root.Descendants(Const.c + "Tables")
                             select element;

                    if (tablesNodes.Count<XElement>() > 0)//说明存在类型，就是数据库模型
                    {
                        _mt = ModelType.Database;
                    }
                    else
                    {
                        throw new Exception("非法模型文件，系统只支持领域模型和数据库模型！");
                    }

                }

            }
            catch (Exception e)
            {
                MessageBox.Show("读取model出错！\r\n" + e.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

        }

        public ModelAnalyserLinq(String fileName, ModelType mt)
        {
            try
            {
                _mt = mt;
                root = XElement.Load(fileName);
            }
            catch (Exception e)
            {
                MessageBox.Show("读取model出错！\r\n" + e.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

        }

        public ModelType MT
        {
            get { return _mt; }
        }

        /// <summary>
        /// 获取模型的基本对象集合，特指表集合或者实体集合
        /// </summary>
        /// <returns></returns>
        public List<ModelElement> GetObjectList()
        {
            List<ModelElement> list = new List<ModelElement>();
            if (_mt == ModelType.Domain)
            {

                var classNodes = from element in root.Descendants(Const.o + "Class")
                                 where element.Parent !=null
                                 && element.Parent.Name == Const.c + "Classes"
                                   select element;

                foreach (XElement n in classNodes)
                {
                    ModelElement attr = GenerateElementFromNode(n);
                    list.Add(attr);
                }
            
            }
            else
            {
                var tableNodes = from element in root.Descendants(Const.o + "Table")
                                 where element.Parent != null
                                && element.Parent.Name == Const.c + "Tables"
                                 select element;

                foreach (XElement n in tableNodes)
                {
                    ModelElement attr = GenerateElementFromNode(n);
                    IEnumerable<XElement>  tmp = n.Descendants(Const.a + "Comment");
                    if (tmp.Count<XElement>() > 0 )
                    {
                        attr.Comment = tmp.First<XElement>().Value;
                    }
                    list.Add(attr);
                }
            }
      
            return list;
        }

        /// <summary>
        /// 根据xml节点获取对应的ModelElement
        /// </summary>
        /// <param name="n"></param>
        /// <returns></returns>
        private ModelElement GenerateElementFromNode(XElement n)
        {      
            ModelElement attr = new ModelElement();

            attr.Code = GetElementValueFromClassTable(n.FirstAttribute.Value, "Code");
            attr.CreationDate = GetElementValueFromClassTable(n.FirstAttribute.Value, "CreationDate");
            attr.Creator = GetElementValueFromClassTable(n.FirstAttribute.Value, "Creator");
            attr.ModificationDate = GetElementValueFromClassTable(n.FirstAttribute.Value, "ModificationDate");
            attr.Modifier = GetElementValueFromClassTable(n.FirstAttribute.Value, "Modifier");
            attr.Name = GetElementValueFromClassTable(n.FirstAttribute.Value, "Name");
            attr.ObjectID = GetElementValueFromClassTable(n.FirstAttribute.Value, "ObjectID");
            attr.Code = GetElementValueFromClassTable(n.FirstAttribute.Value, "Code");

            return attr;
        }

        private  String GetElementValueFromClassTable(string classID, string property)
        {
            IEnumerable<XElement> tmpList = from t2 in root.Descendants(Const.a + property)
                                            where t2.Parent != null
                                                && t2.Parent.FirstAttribute != null
                                                && t2.Parent.FirstAttribute.Value == classID
                                            select t2;
            if (tmpList.Count<XElement>() == 0)
                return String.Empty;
            return tmpList.First<XElement>().Value;
        }

        /// <summary>
        /// 根据对象ID找到属性列表
        /// </summary>
        /// <param name="objectID"></param>
        /// <returns></returns>
        public List<ModelElement> GetAttributeList(string objectID)
        {
            List<ModelElement> list = new List<ModelElement>();
            XElement node = FindNodeByObjectID(objectID);

            string classOrTable = String.Empty;

            if (_mt == ModelType.Domain)
            {
                classOrTable = "Attribute";
            }
            else
            {
                classOrTable = "Column";
            }

            IEnumerable<XElement> listAttr =
                        from el in root.Descendants(Const.o + classOrTable)
                        where el.Parent != null
                        && el.Parent .Parent != null
                        && el.Parent.Parent.FirstAttribute != null
                        && FindNodeByObjectID(objectID) != null
                        && FindNodeByObjectID(objectID).Parent  != null
                        && FindNodeByObjectID(objectID).Parent.FirstAttribute != null
                        && el.Parent.Parent.FirstAttribute.Value == FindNodeByObjectID(objectID).Parent.FirstAttribute.Value
                        select el;

            foreach (XElement n in listAttr)
            {
                ModelElement ma = GenerateElementFromNode(n);
                list.Add(ma);
            }
            return list;
        }

        /// <summary>
        /// 根据对象id（guid）找到对应的节点
        /// </summary>
        /// <param name="objectID"></param>
        /// <returns></returns>
        private XElement FindNodeByObjectID(string objectID)
        {
            IEnumerable<XElement> list =
                            from el in root.Descendants(Const.a + "ObjectID")
                            where el.Value == objectID
                            select el;
            if (list.Count<XElement>() > 0)
                return list.First<XElement>();
            else
                return null;
        
        }

    }

 class Const
    {
        public readonly static XNamespace a =  "attribute", c = "collection", o = "object";

        public const string cClasses = "c:Classes";
        public const string oClass = "o:Class";

        public const string cAttributes = "c:Attributes";
        public const string oAttribute = "o:Attribute";

        public const string cTables = "c:Tables";
        public const string oTable = "o:Table";

        public const string cColumns = "c:Columns";
        public const string oColumn = "o:Column";
    }

 interface  IModelAnalyser
    {
        List<ModelElement> GetAttributeList(string objectID);
        List<ModelElement> GetObjectList();
        ModelType MT { get; }
    }


    /// <summary>
    /// xml节点entity，可以指定类型：table，class，column，attribute等
    /// </summary>
    public class ModelElement
    {
        /// <summary>
        /// 重写ToString()，给ListView显示用
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return Name + Code + (String.IsNullOrEmpty(Comment) ? "" : Comment);
        }

        //<a:ObjectID>DE001EE1-B9D8-4904-AA97-1CB93DAE107E</a:ObjectID>
        public string ObjectID { get; set; }
        //<a:Name>类型</a:Name>
        public string Name { get; set; }
        //<a:Code>类型</a:Code>
        public string Code { get; set; }
        //<a:CreationDate>1271233784</a:CreationDate>
        public string CreationDate { get; set; }
        //<a:Creator>xiaxilin</a:Creator>
        public string Creator { get; set; }
        //<a:ModificationDate>1271233784</a:ModificationDate>
        public string ModificationDate { get; set; }
        //<a:Modifier>xiaxilin</a:Modifier>
        public string Modifier { get; set; }
        //<a:DataType>java.lang.String</a:DataType>
        public string DataType { get; set; }
        //<a:Attribute.Visibility>-</a:Attribute.Visibility>
        public string Visibility { get; set; }
        //<a:Comment>-</a:Comment>
        public string Comment { get; set; }

    }

    /// <summary>
    /// 模型类型
    /// </summary>
    public enum ModelType
    {
        /// <summary>
        /// 领域模型
        /// </summary>
        Domain = 0,

        /// <summary>
        /// 数据库模型
        /// </summary>
        Database = 1
    }

  /// <summary>
    /// 通过Xml分析powerdesigner模型文件
    /// </summary>
    public class ModelAnalyser : IModelAnalyser
    {
   

        /// <summary>
        /// Xml命名空间管理
        /// </summary>
        XmlNamespaceManager nsmgr = null;

        /// <summary>
        /// 属性列表，记录字段
        /// </summary>
        List<ModelElement> listAtt = new List<ModelElement>();

        /// <summary>
        /// 单元列表：记录领域对象列表或者数据库表对象列表
        /// </summary>
        List<ModelElement> listUnit = new List<ModelElement>();

        /// <summary>
        /// 
        /// </summary>
        ModelType _mt = ModelType.Domain;

        /// <summary>
        /// 一个ModelAnalyser对应一个xmldocument
        /// </summary>
        XmlDocument xd = new XmlDocument();

        public ModelAnalyser(String fileName)
            : this(fileName, ModelType.Domain)
        {
            try
            {
                XmlNode node = xd.SelectSingleNode("//" + Const.cClasses, nsmgr);
                if (node != null)//说明存在类型，就是领域模型，数据库模型中不存在这个的
                {
                    _mt = ModelType.Domain;
                }
                else
                {
                    XmlNode node2 = xd.SelectSingleNode("//" + Const.cTables, nsmgr);
                    if (node2 != null)//说明存在类型，就是数据库模型
                    {
                        _mt = ModelType.Database;
                    }
                    else
                    {
                        throw new Exception("非法模型文件，系统只支持领域模型和数据库模型！");
                    }

                }

            }
            catch (Exception e)
            {
                MessageBox.Show("读取model出错！\r\n" + e.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

        }

        public ModelAnalyser(String fileName, ModelType mt)
        {
            try
            {
                _mt = mt;
                xd.Load(fileName);

                nsmgr = new XmlNamespaceManager(xd.NameTable);
                nsmgr.AddNamespace("a", "attribute");
                nsmgr.AddNamespace("c", "collection");
                nsmgr.AddNamespace("o", "object");

            }
            catch (Exception e)
            {
                MessageBox.Show("读取model出错！\r\n" + e.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

        }

        public ModelType MT
        {
            get { return _mt; }
        }

        /// <summary>
        /// 获取模型的基本对象集合，特指表集合或者实体集合
        /// </summary>
        /// <returns></returns>
        public List<ModelElement> GetObjectList()
        {
            List<ModelElement> list = new List<ModelElement>();
            if (_mt == ModelType.Domain)
            {
                XmlNode node = xd.SelectSingleNode("//" + Const.cClasses, nsmgr);
                if (node != null)
                {
                    foreach (XmlNode n in node.ChildNodes)
                    {
                        ModelElement attr = GenerateElementFromNode(n);
                        list.Add(attr);
                    }
                }
            }
            else
            {
                XmlNode node = xd.SelectSingleNode("//" + Const.cTables, nsmgr);
                if (node != null)
                {
                    foreach (XmlNode n in node.ChildNodes)
                    {
                        ModelElement attr = GenerateElementFromNode(n);
                        XmlNode tmp = n.SelectSingleNode("a:Comment", nsmgr);
                        if (tmp != null)
                        {
                            attr.Comment = tmp.InnerText;
                        }
                        list.Add(attr);
                    }
                }
            }
            return list;
        }

        /// <summary>
        /// 根据xml节点获取对应的ModelElement
        /// </summary>
        /// <param name="n"></param>
        /// <returns></returns>
        private ModelElement GenerateElementFromNode(XmlNode n)
        {
            ModelElement attr = new ModelElement();
            attr.Code = n.SelectSingleNode("a:Code", nsmgr).InnerText;
            attr.CreationDate = n.SelectSingleNode("a:CreationDate", nsmgr).InnerText;
            attr.Creator = n.SelectSingleNode("a:Creator", nsmgr).InnerText;
            attr.ModificationDate = n.SelectSingleNode("a:ModificationDate", nsmgr).InnerText;
            attr.Modifier = n.SelectSingleNode("a:Modifier", nsmgr).InnerText;
            attr.Name = n.SelectSingleNode("a:Name", nsmgr).InnerText;
            attr.ObjectID = n.SelectSingleNode("a:ObjectID", nsmgr).InnerText;
            return attr;
        }

        /// <summary>
        /// 根据对象ID找到属性列表
        /// </summary>
        /// <param name="objectID"></param>
        /// <returns></returns>
        public List<ModelElement> GetAttributeList(string objectID)
        {
            List<ModelElement> list = new List<ModelElement>();
            XmlNode node = FindNodeByObjectID(objectID);
            foreach (XmlNode n in node.ChildNodes)
            {
                ModelElement ma = GenerateElementFromNode(n);
                list.Add(ma);
            }
            return list;
        }

        /// <summary>
        /// 根据对象id（guid）找到对应的节点
        /// </summary>
        /// <param name="objectID"></param>
        /// <returns></returns>
        private XmlNode FindNodeByObjectID(string objectID)
        {
            XmlNodeList nodeList = null;
            if (_mt == ModelType.Domain)
            {
                nodeList = xd.SelectSingleNode("//" + Const.cClasses, nsmgr).ChildNodes;
            }
            else
            {
                nodeList = xd.SelectSingleNode("//" + Const.cTables, nsmgr).ChildNodes;
            }

            foreach (XmlNode n in nodeList)
            {
                if (n.SelectSingleNode("a:ObjectID", nsmgr).InnerText == objectID)
                {
                    if (_mt == ModelType.Domain)
                    {
                        return n.SelectSingleNode("//" + Const.cAttributes, nsmgr);
                    }
                    else
                    {
                        return n.SelectSingleNode("//" + Const.cColumns, nsmgr);
                    }
                }
            }
            return null;
        }

    }