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

 public IObjectContext CreateForDeserialization(IMemberContext targetMember, Type targetType, IAdviceRequester adviceRequester)
 {
     return Factories
         .Select(f => f.CreateForDeserialization(targetMember, targetType, adviceRequester))
         .Where(d => d != null)
         .FirstOrDefault();
 }

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

 public IObjectContext CreateForSerialization(IMemberContext sourceMember, object source, IAdviceRequester adviceRequester)
 {
     return Factories
         .Select(f => f.CreateForSerialization(sourceMember, source, adviceRequester))
         .Where(d => d != null)
         .FirstOrDefault();
 }

        public bool Serialize(IMemberContext source, XObject target, IAdviceRequester adviceRequester)
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (target.NodeType != XmlNodeType.Element)
                throw new ArgumentException("Parameter must be an XML element.", "target");

            var elem = (XElement)target;

            IObjectContext sourceObject = source.GetValue();

            if (sourceObject == null || sourceObject.GetObject() == null)
            {
                if (_isNullableStrategy.IsNullable(source, elem, adviceRequester))
                {
                    elem.Add(Constants.XsiNilAttribute);
                    return true;
                }

                return false;
            }

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

            SerializeRecursively(elem, mappings, adviceRequester);

            return true;
        }

		// TODO: Replace IMemberContext with MemberCore
		public EmitContext (IMemberContext rc, ILGenerator ig, TypeSpec return_type)
		{
			this.MemberContext = rc;
			this.ig = ig;

			this.return_type = return_type;
		}

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

            return _serializer;
        }

        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();
        }

        private static IMapping<IMemberContext, XObject> CreateMappingForSerialization(IMemberContext member, XElement target)
        {
            var targetTypeAndName = GetTargetTypeAndName(member);

            XObject xobj;
            bool addTargetToParent = true;
            switch (targetTypeAndName.Key)
            {
                case XmlNodeType.Element:
                    if (!member.ContractType.IsSubTypeOf<IXmlSerializable>() && member.ContractType.IsCollectionType() && HasXmlElementAttribute(member) || HasXmlTextAttribute(member))
                    {
                        xobj = target;
                        addTargetToParent = false;
                    }
                    else
                        xobj = new XElement(targetTypeAndName.Value);
                    break;
                case XmlNodeType.Attribute:
                    xobj = new XAttribute(targetTypeAndName.Value, string.Empty);
                    break;
                default:
                    throw new ArgumentOutOfRangeException("Mapped to an unknown node type: " + targetTypeAndName.Key + ".");
            }

            return new Mapping<IMemberContext, XObject>(member, xobj, addTargetToParent);
        }

        public IEnumerable<IMapping<XObject, IMemberContext>> MapForDeserialization(XElement source, IMemberContext target, IAdviceRequester adviceRequester)
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (target == null)
                throw new ArgumentNullException("target");

            var targetObject = target.GetValue();
            foreach (var member in targetObject.Members.Where(m => !m.Attributes.OfType<XmlIgnoreAttribute>().Any()))
            {
                var sourceType = GetSourceTypeAndPotentialNames(member);

                switch (sourceType.Key)
                {
                    case XmlNodeType.Element:
                        foreach (var mapping in GetMappingsFromElement(sourceType.Value, source, targetObject, member, adviceRequester))
                            yield return mapping;
                        break;
                    case XmlNodeType.Attribute:
                        yield return GetMappingFromAttribute(sourceType.Value, source, member);
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }

        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 static Type GetActualTypeFromXmlElementAttribute(XElement source, IMemberContext target)
        {
            if (source == null)
                return null;

            return GetTypeFromXmlElementAttributeWithMatchingName(source, target)
                   ?? GetTypeFromXmlElementAttributeWithoutName(target);
        }

        public override IDeserializer Select(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
        {
            var contractTypeFromAttr = GetContractTypeFromAttributes(source, target);
            if (contractTypeFromAttr == null)
                return null;

            return Select(source, target, contractTypeFromAttr, adviceRequester);
        }

 public MultipleMatchesAdviceRequestedEventArgs(XElement source, IObjectContext targetOwner, IMemberContext target, IEnumerable<XObject> matches, XObject selectedMatch)
     : base(CommonAdviceTypes.MultipleMatches)
 {
     Source = source;
     TargetOwner = targetOwner;
     Target = target;
     Matches = (matches ?? Enumerable.Empty<XObject>()).ToList();
     SelectedMatch = selectedMatch;
 }

		public bool ResolveType(IMemberContext mc, TypeSpec defaultType)
		{
			if (TypeExpression != null)
				this.Type = TypeExpression.ResolveAsType (mc);
			else
				this.Type = defaultType;

			return this.Type != null;
		}

        public IObjectContext CreateForSerialization(IMemberContext sourceMember, object source, IAdviceRequester adviceRequester)
        {
            if (source == null)
                return null;

            ObjectContextInfo contextInfo = GetContextInfo(source.GetType(), adviceRequester);

            return contextInfo.CreateFor(source);
        }

        public IObjectContext CreateForDeserialization(IMemberContext targetMember, Type targetType, IAdviceRequester adviceRequester)
        {
            ObjectContextInfo contextInfo = GetContextInfo(targetType, adviceRequester);

            object target = _instantiator.Create(targetType, adviceRequester);
            if (target == null)
                throw new ArgumentException("Unable to create instance of '" + targetType + "' for member '" + targetMember + "'.");

            return contextInfo.CreateFor(target);
        }

 private static Type GetTypeFromXmlAttributeAttributeWithoutName(IMemberContext target)
 {
     return target.Attributes
             .OfType<XmlAttributeAttribute>()
             .Where(a => string.IsNullOrWhiteSpace(a.AttributeName))
             .Where(a => a.Type != null)
             .Where(a => target.ContractType.IsAssignableFrom(a.Type))
             .Select(a => a.Type)
             .FirstOrDefault();
 }

		protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec)
		{
			var type = ec.Module.PredefinedTypes.Nullable.Resolve (loc);
			if (type == null)
				return null;

			TypeArguments args = new TypeArguments (underlying);
			GenericTypeExpr ctype = new GenericTypeExpr (type, args, loc);
			return ctype.ResolveAsTypeTerminal (ec, false);
		}

		public override TypeExpr ResolveAsType (IMemberContext ec)
		{
			var type = ec.Module.PredefinedTypes.Nullable.Resolve ();
			if (type == null)
				return null;

			TypeArguments args = new TypeArguments (underlying);
			GenericTypeExpr ctype = new GenericTypeExpr (type, args, loc);
			return ctype.ResolveAsType (ec);
		}