Paser体系

using System;
using System.Collections.Generic;

namespace GTP.Workflow.Process.Parsers
{
    public abstract class ParserImpl : IParser
    {
        private IParserFactory _factory;

        protected Object _object;
        protected IXMLNode _content;

        protected Process _process;

        protected abstract object DoCreateObject();

        protected virtual void DoBeforeParse()
        {
            if (_object == null)
                _object = DoCreateObject();
        }

        protected abstract void DoParseAttribute();

        protected virtual void DoAfterParse()
        {
            // do nothing
        }

        protected virtual void DoBeforeParseChildNode(IXMLNode node, IParser parser)
        {
            // do nothing
        }

        protected virtual void DoParseChildNode(IXMLNode node, IParser parser)
        {
            DoBeforeParseChildNode(node, parser);
            parser.XMLToObject(node);
            DoAfterParseChildNode(node, parser);
        }

        protected virtual void DoParseChildren(params string[] names)
        {
            List<IXMLNode> list = this._content.GetChildren();
            IList<string> names2 = (IList<string>)names;

            for (int i = 0; i < list.Count; i++)
            {
                IXMLNode node = list[i];
                if (names2.Count == 0)
                {
                    IParser parser = this.Factory.CreateParser(node.GetName());
                    DoParseChildNode(node, parser);
                }
                else if (names2.Contains(node.GetName()))
                {
                    IParser parser = this.Factory.CreateParser(node.GetName());
                    DoParseChildNode(node, parser);
                }
            }
        }

        protected virtual void DoAfterParseChildNode(IXMLNode node, IParser parser)
        {
            // do nothing
        }

        public Process Process
        {
            get { return _process; }
            set { _process = value; }
        }

        protected virtual void DoSetObject(Object value)
        {
            _object = value;
        }

        public Object Object
        {
            get { return _object; }
            set { DoSetObject(value); }
        }

        public IParserFactory Factory
        {
            get { return _factory; }
            set { _factory = value; }
        }

        public virtual void XMLToObject(IXMLNode rootNode)
        {
            this._content = rootNode;

            DoBeforeParse();
            DoParseAttribute();
            DoParseChildren();
            DoAfterParse();
        }

        public virtual void Init()
        {
            // do nothing
        }

        public virtual void Clear()
        {
            // do nothing
        }

        protected virtual void DoBeforeSerialize()
        {
            if (_object == null)
                _object = DoCreateObject();
        }

        protected virtual void DoSerialize()
        {
            // do nothing
        }

        protected void DoSerializeObject(Object obj, string name = "")
        {
            string lname = name;
            if (lname == "")
                lname = this.Factory.GetElementName(obj);

            IXMLNode node = this._content.CreateNode(lname);
            IParser parser = this.Factory.CreateParser(obj);
            parser.Object = obj;
            parser.ObjectToXML(node);
            this._content.AddChild(node);
        }

        protected void DoSerializeObject2(Object obj, string name = "")
        {
            string lname = name;
            if (lname == "")
                lname = this.Factory.GetElementName(obj);

            IParser parser = this.Factory.CreateParser(obj);
            parser.Object = obj;
            parser.ObjectToXML(this._content);
        }

        protected void DoSerializeDinctionary<T>(Dictionary<string, T> objs, string name = "", bool sameName = true)
        {
            string lname = name;

            foreach (KeyValuePair<string, T> entry in objs)
            {
                T obj = entry.Value;

                if ((lname == "") && sameName)
                    lname = this.Factory.GetElementName(obj);

                DoSerializeObject(obj, lname);
            }
        }

        protected void DoSerializeList<T>(List<T> objs, string name = "", bool sameName = true)
        {
            string lname = name;

            for (int i = 0; i < objs.Count; i++)
            {
                T obj = objs[i];

                if ((lname == "") && sameName)    // todo ts 速度会慢
                    lname = this.Factory.GetElementName(obj);

                DoSerializeObject(obj, lname);
            }
        }

        protected virtual void DoAfterSerialize()
        {
            // do nothing
        }

        public virtual void ObjectToXML(IXMLNode rootNode)
        {
            this._content = rootNode;

            DoBeforeSerialize();
            DoSerialize();
            DoAfterSerialize();
        }

    }
}

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------具体Paser类

 public class ScriptTaskParser : HandlerTaskParser
    {
        protected override object DoCreateObject()
        {
            return new ScriptTask();
        }

        protected override void DoParseAttribute()
        {
            base.DoParseAttribute();
        }

        protected override void DoBeforeParseChildNode(IXMLNode node, IParser parser)
        {
            if (parser is ScriptParser)
                parser.Object = ScriptTask.Script;
            else
                base.DoBeforeParseChildNode(node, parser);
        }

        protected override void DoSerialize()
        {
            base.DoSerialize();

            base.DoSerializeObject(this.ScriptTask.Script);
        }

        public ScriptTask ScriptTask
        {
            get { return (ScriptTask)this.Object; }
        }
    }
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------xmlImpl实现

 

public class XMLNodeImpl : IXMLNode
    {
        private XmlElement _element;

        public XMLNodeImpl(XmlElement element)
        {
            this._element = element;
        }

        public string GetName()
        {
            return _element.Name;
        }

        public string GetAttributeStringValue(string id, string defalutValue = "")
        {
            return (_element.Attributes[id] == null) ? defalutValue : _element.Attributes[id].Value;
        }

        public int GetAttributeIntValue(string id, int defaultValue = 0)
        {
            return (_element.Attributes[id] == null) ? defaultValue : Int32.Parse(GetAttributeStringValue(id));
        }

        public bool GetAttributeBoolValue(string id, bool defaultValue = false)
        {
            return (_element.Attributes[id] == null) ? defaultValue : Boolean.Parse(GetAttributeStringValue(id));
        }

        public List<IXMLNode> GetChildren()
        {
            List<IXMLNode> list = new List<IXMLNode>();
            for (int i = 0; i < _element.ChildNodes.Count; i++)
            {
                if (_element.ChildNodes[i] is XmlElement)
                {
                    XmlElement element = (XmlElement)_element.ChildNodes[i];
                    IXMLNode node = new XMLNodeImpl(element);
                    list.Add(node);
                }
            }
            return list;
        }

        public IXMLNode CreateNode(string name)
        {
            XmlElement element = this._element.OwnerDocument.CreateElement(name);
            IXMLNode node = new XMLNodeImpl(element);
            return node;
        }

        public void AddChild(IXMLNode node)
        {
            XMLNodeImpl nodeImpl = (XMLNodeImpl)node;
            this._element.AppendChild(nodeImpl._element);
        }

        public void SetAttributeStringValue(string id, string value, string defaultValue = "")
        {
            if (string.IsNullOrEmpty(value))
                return;
            if (value.Equals(defaultValue))
                return;

            this._element.SetAttribute(id, value);
        }

        public void SetAttributeBoolValue(string id, bool value, bool defaultValue = false)
        {
            if (value.Equals(defaultValue))
                return;

            this._element.SetAttribute(id, value ? "true" : "false");
        }

        public void SetAttributeIntValue(string id, int value, int defaultValue = 0)
        {
            if (value.Equals(defaultValue))
                return;

            this._element.SetAttribute(id, value.ToString());
        }
    }

-------------------------------------------------------paserFactory

 public class ParserFactory
    {
        public static ParserImpl CreateParserByName(string name)
        {
            ParserImpl result = null;
            switch (name)
            {
                case "person":
                    result = new PersonParser();
                    break;
                case "adress":
                    result = new AdressParser();
                    break;
                case "url":
                    result = new UrlParser();
                    break;
            }
            return result;

        }
        public static string GetNameBySource(object obj)
        {
            string name = null;

            if (obj is Person)
            {
                name = "person";
            }
            else if (obj is Adress)
            {
                name = "adress";
            }
            else if (obj is Url)
            {
                name = "url";
            }

            return name;

        }
    }