C# XObject类代码示例

 public object Parse(Type type, XObject config, bool isAssignableTypeAllowed, XmlLocation childLocation, IContext context)
 {
     var xel = config as XElement;
     if (xel == null)
         throw new TestLibsException($"Couldn't cast following config to XElement:\n{config}");
     return xel;
 }

 public int? GetNodeCount(XObject xml, string xpath)
 {
     if(xml == null)
     {
         return null;
     }
     if(xml.Document == null)
     {
         return null;
     }
     if(xml.Document.Root == null)
     {
         return null;
     }
     try
     {
         var namespaceResolver = new SimpleXmlNamespaceResolver(xml.Document);
         var results = (IEnumerable)xml.Document.XPathEvaluate(xpath, namespaceResolver);
         return results.OfType<XObject>().Count();
     }
     catch(Exception)
     {
         return null;
     }
 }

        public ISerializer Select(IMemberContext source, XObject target, IAdviceRequester adviceRequester)
        {
            if (target.NodeType != XmlNodeType.Element)
                return null;

            return _serializer;
        }

        public static void AreEqual(XObject expected, XObject actual)
        {
            if (expected is XDocument)
            {
                expected = ((XDocument)expected).Root;
            }
            if (actual is XDocument)
            {
                actual = ((XDocument)actual).Root;
            }

            if (expected == null && actual == null)
            {
                return;
            }
            if (expected == null)
            {
                RaiseAssertFailure(null, actual);
                return;
            }
            if (actual == null)
            {
                RaiseAssertFailure(expected, null);
                return;
            }
            if (expected.GetType() != actual.GetType())
            {
                RaiseAssertFailure(expected, actual);
                return;
            }

            AssertEqualValues(expected, actual);
        }

 public ParseDefinitionFileException(string message, XObject source) 
     : base(GetMessage(message, source))
 {
     _source = source;
     Line = (source as IXmlLineInfo).LineNumber;
     Position = (source as IXmlLineInfo).LinePosition;
 }

        public void Deserialize(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
        {
            if (source == null)
                return;

            if (source.NodeType != XmlNodeType.Element)
                throw new ArgumentException("Parameter must be an XML element.", "source");

            if (_log.IsDebugEnabled)
                _log.Debug("Deserializing " + source.ToFriendlyName() + " into " + target + ".");

            var elem = (XElement)source;

            Type targetType = _typeConverter.GetActualType(source, target, adviceRequester);
            if (targetType == null)
                throw new ArgumentException("Unable to get target type for target '" + target + "'.");

            IObjectContext targetObject = _objectContextFactory.CreateForDeserialization(target, targetType, adviceRequester);
            if (targetObject == null)
                throw new ArgumentException("Unable to create target object for target '" + target + "'.");

            target.SetValue(targetObject);

            List<IMapping<XObject, IMemberContext>> mappings = _mapper.MapForDeserialization(elem, target, adviceRequester)
                .ToList();
            if (mappings == null)
                throw new ArgumentException("Unable to map source '" + source + "' and target '" + target + "'.");

            DeserializeRecursively(mappings, adviceRequester);

            target.CommitChanges();
        }

 public EventsHelper(XObject x)
 {
     _root = x;
     _root.Changing += new EventHandler<XObjectChangeEventArgs>(Changing);
     _root.Changed += new EventHandler<XObjectChangeEventArgs>(Changed);
     _events = new Queue<EventItem>();
 }

        public override void AddSubcomponent(string name, XObject sub)
        {
			if (this.Levels == null)
				this.Levels = new List<XLevelInfo>();
            
			this.Levels.Add((XLevelInfo)sub);
		}

        protected virtual IDeserializer Select(XObject source, IMemberContext target, Type type, IAdviceRequester adviceRequester)
        {
            var typeCode = Type.GetTypeCode(type);

            switch (typeCode)
            {
                case TypeCode.Empty:
                case TypeCode.DBNull:
                    return null;
                case TypeCode.Object:
                    if (target.ContractType == typeof(TimeSpan))
                        break;
                    if (target.ContractType == typeof(string))
                        break;
                    if (target.ContractType.IsNullable())
                        break;

                    return null;
            }

            if (source == null)
                return GetDeserializer(type);

            if (source.NodeType == XmlNodeType.Element && !((XElement)source).HasElements)
                return GetDeserializer(type);

            if (source.NodeType == XmlNodeType.Attribute)
                return GetDeserializer(type);

            return null;
        }

 private XObject FindObject(string id, XObject root)
 {
     var o = root.FindLocal(id);
     if (o == null)
         throw new InvalidOperationException(string.Format("Iterator '{0}' could not find obect id: '{1}'", this.Id, id));
     return o;
 }

 public IDeserializer Select(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
 {
     return Selectors
             .Select(s => s.Select(source, target, adviceRequester))
             .Where(d => d != null)
             .FirstOrDefault();
 }

 /// <summary>
 /// Initializes a new instance.
 /// </summary>
 /// <param name="xml"></param>
 /// <param name="context"></param>
 /// <param name="xpath"></param>
 internal Binding(XObject xml, EvaluationContext context, string xpath)
     : this(xml, context, context.CompileXPath(xml, xpath))
 {
     Contract.Requires<ArgumentNullException>(xml != null);
     Contract.Requires<ArgumentNullException>(context != null);
     Contract.Requires<ArgumentNullException>(xpath != null);
 }

 private void setRoot(XObject root)
 {
     if (root is XDocument)
         _current = ((XDocument)root).Root;
     else
         _current = root;
 }

 public Type GetActualType(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
 {
     return Converters
             .Select(c => c.GetActualType(source, target, adviceRequester))
             .Where(t => t != null)
             .FirstOrDefault();
 }

		public void CopyAttributes(XObject src, XObject dest)
		{
			dest.Id = src.Id;
			//dest.Class = src.Class;
			
			dest.Enabled = src.Enabled;
			
			// Element
			var srcElement = src as XElement;
			if (srcElement != null)
			{
				var destElement = (XElement)dest;
				
				destElement.Bounds = srcElement.Bounds;
				
				if (srcElement.backColor.HasValue)
					destElement.BackColor = srcElement.BackColor;

				if (srcElement.Rotation != 0)
					destElement.Rotation = srcElement.Rotation;
			}
			
			// IHasPoints
			var srcHasPoints = src as IHasPoints;
			if (srcHasPoints != null && srcHasPoints.Points != 0)
			{
				((IHasPoints)dest).Points = srcHasPoints.Points;
			}
			
			var srcEnemy = src as XEnemy;
			if (srcEnemy != null && srcEnemy.DamageSpecified)
			{
				((XEnemy)dest).Damage = srcEnemy.Damage;
			}
		}