protected override object GetValueFromXml(XElement root, XName name, PropertyInfo prop)
        {
            var isAttribute = false;

            // Check for the DeserializeAs attribute on the property
            var options = prop.GetAttribute<DeserializeAsAttribute>();

            if (options != null)
            {
                name = options.Name ?? name;
                isAttribute = options.Attribute;
            }

            if (isAttribute)
            {
                var attributeVal = GetAttributeByName(root, name);

                if (attributeVal != null)
                {
                    return attributeVal.Value;
                }
            }

            return base.GetValueFromXml(root, name, prop);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="PropertyManager"/> class.
 /// </summary>
 public PropertyManager(string schema)
 {
     keyElementName = XName.Get("Key", schema);
     entityTypeName = XName.Get(entityTypeNameString, schema);
     entityContainerName = XName.Get("EntityContainer", schema);
     entitySetName = XName.Get("EntitySet", schema);
 }

        public static void SetValue(XElement _parent, PropertyExtensionContext _context, XName xName, bool value)
        {
            bool propertyValue = value;

            // Make changes to the .edmx document in an EntityDesignerChangeScope to enable undo/redo of changes.
            using (EntityDesignerChangeScope scope = _context.CreateChangeScope("Set EDMXFileTools"))
            {
                if (_parent.HasElements)
                {
                    XElement lastChild = _parent.Elements().Where<XElement>(element => element != null && element.Name == xName).LastOrDefault();
                    if (lastChild != null)
                    {
                        // Property element already exists under the EntityType element, so update its value.
                        lastChild.SetValue(propertyValue.ToString());
                    }
                    else
                    {
                        // Property element does not exist, so create a new one as the last child of the EntityType element.
                        _parent.Elements().Last().AddAfterSelf(new XElement(xName, propertyValue.ToString()));
                    }
                }
                else
                {
                    // The element has no child elements so create a new MyNewProperty element as its first child.
                    _parent.Add(new XElement(xName, propertyValue.ToString()));
                }

                // Commit the changes.
                scope.Complete();
            }
        }

 private static XDocument CreateDocument(XName rootName, IFileSystem fileSystem, string path)
 {
     XDocument document = new XDocument(new XElement(rootName));
     // Add it to the file system
     fileSystem.AddFile(path, document.Save);
     return document;
 }

        /// <summary>
        ///     Adds a new attribute to the element
        ///     Does not permit modification of an existing attribute.
        ///     Does not add empty or null attributes or values.
        /// </summary>
        /// <param name="element">The element to add the attribute to</param>
        /// <param name="attribute">The attribute to add</param>
        /// <param name="value">the value of the attribute to add</param>
        /// <returns>The element passed in. (Permits fluent usage)</returns>
        internal static XElement AddAttribute(this XElement element, XName attribute, string value) {
            if (element == null) {
                return null;
            }

            // we quietly ignore attempts to add empty data or attributes.
            if (string.IsNullOrWhiteSpace(value) || attribute == null || string.IsNullOrWhiteSpace(attribute.ToString())) {
                return element;
            }

            // Swidtag attributes can be added but not changed -- if it already exists, that's not permitted.
            var current = element.GetAttribute(attribute);
            if (!string.IsNullOrWhiteSpace(current)) {
                if (value != current) {
                    throw new Exception("Attempt to change Attribute '{0}' present in element '{1}'".format(attribute.LocalName, element.Name.LocalName));
                }

                // if the value was set to that already, don't worry about it.
                return element;
            }

            element.SetAttributeValue(attribute, value);

            return element;
        }

		public static IEnumerable<XElement> Ancestors(this XNode node, XName name, bool ignoreNamespace)
		{
			if (ignoreNamespace)
				return node.Ancestors().Where(e => e.Name.LocalName == name.LocalName);
			else
				return node.Ancestors(name);
		}

		public static IEnumerable<XElement> ElementsAfterSelf(this XContainer node, XName name, bool ignoreNamespace)
		{
			if (ignoreNamespace)
				return node.ElementsAfterSelf().Where(e => e.Name.LocalName == name.LocalName);
			else
				return node.ElementsAfterSelf(name);
		}

        internal XElement ExecuteFSMSubGroup(IEnumerator<XElement> enumerator, XName[] namesInList) {
            
            Debug.Assert(namesInList != null);

            XElement currElem = null;
            WildCard matchingWildCard = null;
            XName matchingName = null;
            
            while(enumerator.MoveNext()){
                currElem = enumerator.Current;
                currentState = FsmMakeTransition(currentState, currElem.Name, out matchingName, out matchingWildCard);
                                 
                if (currentState!= FSM.InvalidState) {
                      if ( matchingName != null) 
                          for(int i =0; i < namesInList.Length; i++) {
                            if (namesInList.GetValue(i).Equals(currElem.Name)) return currElem;
                          }
                }
                else {//Get stuck. No recovery attempt is provided for now.
                    return null;
                }
            }
         
             //No matching elements/wildcards are found
             return null;
        }

 internal XElement ExecuteFSM(IEnumerator<XElement> enumerator, XName requestingXName, WildCard requestingWildCard) {
     
     XElement currElem = null;
     WildCard matchingWildCard = null;
     XName matchingName = null;
     
     while(enumerator.MoveNext()){
         currElem = enumerator.Current;
         currentState = FsmMakeTransition(currentState, currElem.Name, out matchingName, out matchingWildCard);
                          
         if (currentState!= FSM.InvalidState) {
               if ( (requestingXName != null) && (matchingName != null)) {
                    if (requestingXName.Equals(currElem.Name)) return currElem;
               }
               else if ( (requestingWildCard != null) && (matchingWildCard != null) ){//requesting for ANY
                 if (requestingWildCard.Allows(currElem.Name)) //Make sure current element is allowed by requesting ANY property
                     return currElem;                            
             }
         } 
         else {//Get stuck. No recovery attempt is provided for now.
             return null;
         }
     }
  //No matching elements/wildcards are found
  return null;
 }

        internal XElement GenerateXElement(XName name)
        {
            XNamespace xmlns = name.Namespace;
            XElement element = new XElement(name);

            return element;
        }

 public static string GetElementValue(this XContainer elem, XName elementName)
 {
     XElement childElement = elem.Element(elementName);
     if (childElement != null)
         return childElement.Value;
     return null;
 }

 public static string GetAttribute(this XElement elem, XName attributeName)
 {
     XAttribute attribute = elem.Attribute(attributeName);
     if (attribute != null)
         return attribute.Value;
     return null;
 }

 internal static string AttributeValue(this XElement xml, XName attributeName)
 {
     var attribute = xml.Attribute(attributeName);
     if (null == attribute)
         return null;
     return attribute.Value;
 }

 public static string GetStringAttribute(this XElement element, XName name)
 {
     XAttribute xattribute = element.Attribute(name);
     if (xattribute != null)
         return xattribute.Value;
     return string.Empty;
 }

		public static IEnumerable<XElement> Descendants(this XContainer container, XName name, bool ignoreNamespace)
		{
			if (ignoreNamespace)
				return container.Descendants().Where(e => e.Name.LocalName == name.LocalName);
			else
				return container.Descendants(name);
		}

 public XElement this[XName section]
 {
    get
    {
       return root.Element(section) ?? new XElement(section);
    }
 }

		public static XElement Element(this XContainer node, XName name, bool ignoreNamespace)
		{
			if (ignoreNamespace)
				return node.Elements().FirstOrDefault(e => e.Name.LocalName == name.LocalName);
			else
				return node.Element(name);
		}

 public static string GetAttributeValue(this XElement element, XName name) {
     XAttribute xAttribute = element.Attribute(name);
     if (xAttribute != null) {
         return xAttribute.Value;
     }
     return null;
 }

 public static string GetAttribute(this XElement el, XName name, string defaultValue = "")
 {
     var attr = el.Attribute(name);
     if (attr != null)
         return attr.Value;
     return defaultValue;
 }

 public XElement SerializeRoot(object obj, Type rootType, XName name, XSerializerNamespaceCollection namespaces, SerializationScope globalScope)
 {
     Debug.Assert(rootType.IsInstanceOfType(obj));
     Debug.Assert(namespaces != null);
     var root = SerializeXElement(obj, rootType, name, globalScope);
     //导入命名空间。
     foreach (var ns in namespaces)
         root.SetAttributeValue(XNamespace.Xmlns + ns.Prefix, ns.Uri);
     //处理导入的类型。
     var nsCounter = 0;
     foreach (var descendant in root.Descendants())
     {
         var actualTypeName = descendant.Annotation<XName>();
         if (actualTypeName != null)
         {
             if (actualTypeName.Namespace == descendant.GetDefaultNamespace())
             {
                 descendant.SetAttributeValue(SerializationHelper.Xsi + "type", actualTypeName.LocalName);
             }
             else
             {
                 var prefix = descendant.GetPrefixOfNamespace(actualTypeName.Namespace);
                 if (prefix == null)
                 {
                     nsCounter++;
                     prefix = "nss" + nsCounter;
                     descendant.SetAttributeValue(XNamespace.Xmlns + prefix, actualTypeName.NamespaceName);
                 }
                 descendant.SetAttributeValue(SerializationHelper.Xsi + "type", prefix + ":" + actualTypeName.LocalName);
             }
             descendant.RemoveAnnotations<XName>();
         }
     }
     return root;
 }