rdlcdocument.cs

微软报表解析器语言生成器。选择微软的报表之后可以把每个节点生成一个实体类

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.IO;
namespace MSReport
{
    public class RDLCDocument
    {
        public RDLCDocument()
        {
        }
        public string NamespaceName
        {
            get
            {
                return _NamespaceName;
            }
            set
            {
                _NamespaceName = value;
            }
        }
        string _NamespaceName = "";

        XmlNamespaceManager nsmgr = null;
        public void LoadRDLC(string Path,string SPath)
        {
            BaseXml(this.NamespaceName);
            _SPath = SPath;
            XmlDocument doc = new XmlDocument();
            doc.Load(Path);

            nsmgr = new XmlNamespaceManager(doc.NameTable);
            nsmgr.AddNamespace("rdlcnms", @"http://schemas.microsoft.com/sqlserver/reporting/2005/01/reportdefinition");
            nsmgr.AddNamespace("rdrdlcnms", @"http://schemas.microsoft.com/SQLServer/reporting/reportdesigner");

            foreach (XmlNode ActXNode in doc.ChildNodes)
            {
                string NodeName = ActXNode.Name;
                ParseNode(ActXNode);
                ChildNode(ActXNode);
            }
        }
        string _SPath = "";
        void ChildNode(XmlNode xmlnode)
        {
            foreach (XmlNode ActXNode in xmlnode.ChildNodes)
            {
                string NodeName = ActXNode.Name;
                ParseNode(ActXNode);
                ChildNode(ActXNode);
            }

        }
        public SortedList<string, RDLCNamespace> NamespaceList = new SortedList<string, RDLCNamespace>();
        void ParseNode(XmlNode xmlnode)
        {
            string xml = "";

            RDLCUsing rusing = new RDLCUsing();
            xml += rusing.Create();

            RDLCNamespace ns = null;
            string nsname = xmlnode.Name.Replace(":","_");
            if (NamespaceList.ContainsKey(nsname))
            {
                ns = NamespaceList[nsname];
            }
            else
            {
                ns = new RDLCNamespace();
            }
            ns.nsmgr = this.nsmgr;
            ns.NamespaceName = _NamespaceName;// "XuMu.Report.Parse";
            xml += ns.Create(xmlnode);
            if (!NamespaceList.ContainsKey(nsname))
            {
                NamespaceList.Add(nsname, ns); ;
            }
            string ClassName = xmlnode.Name.Replace(":", "_");
            FileInfo a = new FileInfo(_SPath+@"\" + ClassName + ".cs");
            FileStream b = a.Create();
            b.Close();

            using (StreamWriter sw = new StreamWriter(_SPath + @"\" + ClassName + ".cs"))
            {
                sw.Write(xml);
            }
            
        }
        public void BaseXml(string Namespace)
        {
            string basexml = @"using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.IO;
using System.Collections;

namespace " + Namespace + @"
{
    public abstract class XMLBase
    {
        
        #region 局部变量
		/// <summary>
		/// 子节点集合
		/// </summary>
		private List<XMLBase> _childElements;
		/// <summary>
		/// 父节点
		/// </summary>
        private XMLBase _parentElement;
        /// <summary>
        /// 字符流
        /// </summary>
		private StringWriter _stringWriter;
		/// <summary>
		/// XML流
		/// </summary>
		private XmlTextWriter _xmlWriter;
        /// <summary>
        /// 服务列表
        /// </summary>
		private System.Collections.ArrayList _Servers=new ArrayList();

        /// <summary>
        /// 标记名
        /// </summary>
        private string _TagName = string.Empty;

		#endregion

		#region 构造函数
		/// <summary>
		/// 初始化子节点集合
		/// </summary>
        public XMLBase()
		{
            _childElements = new List<XMLBase>();
		}
		#endregion
		
		#region 属性
		
		/// <summary>
		/// 设置或获得父节点
		/// </summary>
        public XMLBase ParentElement
		{
			get { return _parentElement; }
			set { _parentElement = value; }
		}
		
		/// <summary>
		/// 获得子节点集合
		/// </summary>
        public List<XMLBase> ChildElements
		{
			get { return _childElements; }
		}

		/// <summary>
		/// 获取或设置节点服务
		/// </summary>
		public System.Collections.ArrayList Servers
		{
			get { return _Servers; }
			set {_Servers.Clear(); _Servers = value; }
		}

        /// <summary>
        /// 标记名   // zzp_chage
        /// </summary>
        public string TagName
        {
            get
            {
                return _TagName;
            }
            set
            {
                _TagName = value;
            }
        }
        XmlNamespaceManager _nsmgr = null;
        public XmlNamespaceManager nsmgr
        {
            get
            {
                return _nsmgr;
            }
            set
            {
                _nsmgr = value;
            }
        }

        /// <summary>
        /// 层次    
        /// </summary>
        public string ElementPath
        {
            get
            {
                if (this.ParentElement == null)
                {
                    if (typeof(XML).IsInstanceOfType(this))
                    {
                        return \""+ XML +@\"";
                    }
                    else
                    {
                        throw new ArgumentException(\""此节点丢失所属的节点!\"");
                    }
                }
                else
                {
                    return this.ParentElement.ElementPath + @\""/\"" + this.TagName;
                }
            }
        }
 
        /// <summary>
        /// 层次
        /// </summary>
        public XmlDocument XmlDoc
        {
            get
            {
                return _XmlDoc;
            }
            set
            {
                _XmlDoc = value;
            }
        }
        internal XmlDocument _XmlDoc = null;
      
		#endregion

		#region 公有方法
		/// <summary>
		/// 添加子节点到子节点集合
		/// </summary>
		/// <param name=\""childElement\"">要添加的子节点</param>
        public void AddChildElements(XMLBase childElement)
		{
			childElement.ParentElement = this;
			if (ChildElementIsValid(childElement))
			{
				_childElements.Add(childElement);
			} 
			else 
			{
				throw new ArgumentException(\""错误的子节点类型 !\"");
			}							
		}
        /// <summary>
        /// 写子节点
        /// </summary>
        /// <returns></returns>
        public string WriteChildElements()
        {

            _stringWriter = new StringWriter();
            _xmlWriter = new XmlTextWriter(_stringWriter);
            _xmlWriter.Formatting = Formatting.Indented;


            this.WriteChildElement(_xmlWriter);
            foreach (XMLBase childElement in _childElements)
            {
                childElement.WriteChildElements(_xmlWriter);
            }
            _xmlWriter.WriteEndElement();

            _xmlWriter.Flush();
            return _stringWriter.ToString();
        }

        /// <summary>
        /// 根据路径把子节点都转化为对项
        /// 
        /// 针对 无属性 ,且包含叶子节点 的对象
        /// </summary>
        /// <param name=\""ElementPath\""></param>
        protected virtual void InitObject(XmlNode ObjectNode, string SubNodeName, XMLBase Instance)
        {
            XmlNodeList ChildList = ObjectNode.SelectNodes(this.ElementPath + @\""/\"" + SubNodeName);
            foreach (XmlNode node in ChildList)
            {
                if (node.Name == SubNodeName)
                {
                    Instance.InitObject(node);
                    if (string.IsNullOrEmpty(Instance.TagName))
                    {
                        Instance.TagName = SubNodeName;
                    }
                    this.AddChildElement(Instance);
                }
            }
        }

        /// <summary>
        /// 获取属性值
        /// </summary>
        /// <param name=\""node\""></param>
        /// <param name=\""name\""></param>
        /// <returns></returns>
        protected virtual string GetNodeAttributeValue(XmlNode node, string name)
        {
            if (node.Attributes[name] == null)
            {
                return null;
            }
            else
            {
                return node.Attributes[name].Value.ToString();
            }
        }

   
		#endregion
		
		#region 静态方法和属性

        	/// <summary>
		/// 添加子节点到子节点集合
		/// </summary>
		/// <param name=\""childElement\"">要添加的子节点</param>
        public abstract void AddChildElement(XMLBase childElement);
		/// <summary>
		/// 静态校验节点方法
		/// </summary>
		/// <param name=\""childElement\"">子节点</param>
		/// <returns></returns>
        public abstract bool ChildElementIsValid(XMLBase childElement);
		        
		/// <summary>
		/// 静态写子节点的方法
		/// </summary>
		/// <param name=\""xmlWriter\""></param>
		public abstract void WriteChildElement(XmlTextWriter xmlWriter);

        /// <summary>
        /// 静态写子节点的方法
        /// </summary>
        /// <param name=\""xmlWriter\""></param>
        public abstract void InitObject(XmlNode ObjectNode);

		#endregion

		#region 帮助方法

		/// <summary>
		/// 写子节点
		/// </summary>
		/// <param name=\""xmlWriter\""></param>
		private void WriteChildElements(XmlTextWriter xmlWriter)
		{
			
			this.WriteChildElement(xmlWriter);
            foreach (XMLBase childElement in _childElements)
			{
				childElement.WriteChildElements(xmlWriter);
			}
			xmlWriter.WriteEndElement();
			xmlWriter.Flush();
		}


 
		#endregion
    }
}
";
            FileInfo a = new FileInfo(_SPath + @"\XMLBase.cs");
            FileStream b = a.Create();
            b.Close();

            using (StreamWriter sw = new StreamWriter(_SPath + @"\XMLBase.cs"))
            {
                sw.Write(Namespace);
            }
        }
    }
}