public XamlObject(XamlType type, object instance)
{
Type = type;
Value = instance;
}
internal static ICustomAttributeProvider GetCustomAttributeProvider(this XamlType type)
{
return(type.UnderlyingType);
}
public XamlObject Set(XamlType type, object instance)
{
Type = type;
Value = instance;
return(this);
}
IEnumerable <XamlNodeInfo> GetNodes(XamlMember xm, XamlObject xobj, XamlType overrideMemberType, bool partOfPositionalParameters)
{
object val;
// Value - only for non-top-level node (thus xm != null)
if (xm != null)
{
// collection items: each item is exposed as a standalone object that has StartObject, EndObject and contents.
if (xm == XamlLanguage.Items)
{
foreach (var xn in GetItemsNodes(xm, xobj))
{
yield return(xn);
}
yield break;
}
// Arguments: each argument is written as a standalone object
if (xm == XamlLanguage.Arguments)
{
foreach (var argm in xobj.Type.GetSortedConstructorArguments())
{
var argv = argm.Invoker.GetValue(xobj.GetRawValue());
var xarg = new XamlObject(argm.Type, argv);
foreach (var cn in GetNodes(null, xarg))
{
yield return(cn);
}
}
yield break;
}
// PositionalParameters: items are from constructor arguments, written as Value node sequentially. Note that not all of them are in simple string value. Also, null values are not written as NullExtension
if (xm == XamlLanguage.PositionalParameters)
{
foreach (var argm in xobj.Type.GetSortedConstructorArguments())
{
foreach (var cn in GetNodes(argm, new XamlObject(argm.Type, xobj.GetMemberValue(argm)), null, true))
{
yield return(cn);
}
}
yield break;
}
if (xm == XamlLanguage.Initialization)
{
yield return(new XamlNodeInfo(TypeExtensionMethods.GetStringValue(xobj.Type, xm, xobj.GetRawValue(), value_serializer_ctx)));
yield break;
}
val = xobj.GetRawValue();
if (xm.DeferringLoader != null)
{
foreach (var xn in GetDeferredNodes(xm, val))
{
yield return(xn);
}
yield break;
}
// don't serialize default values if one is explicitly specified using the DefaultValueAttribute
if (!partOfPositionalParameters && xm.DefaultValue != null && Equals(xm.DefaultValue.Value, val))
{
yield break;
}
// overrideMemberType is (so far) used for XamlLanguage.Key.
var xtt = overrideMemberType ?? xm.Type;
if (!xtt.IsMarkupExtension && // this condition is to not serialize MarkupExtension whose type has TypeConverterAttribute (e.g. StaticExtension) as a string.
(xtt.IsContentValue(value_serializer_ctx) || xm.IsContentValue(value_serializer_ctx)))
{
// though null value is special: it is written as a standalone object.
if (val == null)
{
if (!partOfPositionalParameters)
{
foreach (var xn in GetNodes(null, null_object))
{
yield return(xn);
}
}
else
{
yield return(new XamlNodeInfo(String.Empty));
}
}
else
{
yield return(new XamlNodeInfo(TypeExtensionMethods.GetStringValue(xtt, xm, val, value_serializer_ctx)));
}
yield break;
}
// collection items: return GetObject and Items.
if (xm.Type.IsCollection && !xm.IsWritePublic)
{
yield return(new XamlNodeInfo(XamlNodeType.GetObject, xobj));
// Write Items member only when there are items (i.e. do not write it if it is empty).
var xnm = new XamlNodeMember(xobj, XamlLanguage.Items);
var en = GetNodes(XamlLanguage.Items, xnm.Value).GetEnumerator();
if (en.MoveNext())
{
yield return(new XamlNodeInfo(XamlNodeType.StartMember, xnm));
do
{
yield return(en.Current);
} while (en.MoveNext());
yield return(new XamlNodeInfo(XamlNodeType.EndMember, xnm));
}
yield return(new XamlNodeInfo(XamlNodeType.EndObject, xobj));
yield break;
}
if (xm.Type.IsXData)
{
var sw = new StringWriter();
var xw = XmlWriter.Create(sw, new XmlWriterSettings()
{
OmitXmlDeclaration = true, ConformanceLevel = ConformanceLevel.Auto
});
var val3 = val as IXmlSerializable;
if (val3 == null)
{
yield break; // do not output anything
}
val3.WriteXml(xw);
xw.Dispose();
var obj = new XData()
{
Text = sw.ToString()
};
foreach (var xn in GetNodes(null, new XamlObject(XamlLanguage.XData, obj)))
{
yield return(xn);
}
yield break;
}
}
else
{
val = xobj.GetRawValue();
}
// Object - could become Reference
if (val != null && xobj.Type != XamlLanguage.Reference)
{
if (xm != null && !xm.IsReadOnly && !IsPublicOrVisible(val.GetType()))
{
throw new XamlObjectReaderException($"Cannot read from internal type {xobj.Type}");
}
if (!xobj.Type.IsContentValue(value_serializer_ctx))
{
string refName = NameResolver.GetReferenceName(xobj, val);
if (refName != null)
{
// The target object is already retrieved, so we don't return the same object again.
NameResolver.SaveAsReferenced(val); // Record it as named object.
// Then return Reference object instead.
foreach (var xn in GetNodes(null, new XamlObject(XamlLanguage.Reference, new Reference(refName))))
{
yield return(xn);
}
yield break;
}
else
{
// The object appeared in the xaml tree for the first time. So we store the reference with a unique name so that it could be referenced later.
NameResolver.SetNamedObject(val, true); // probably fullyInitialized is always true here.
}
}
yield return(new XamlNodeInfo(XamlNodeType.StartObject, xobj));
// If this object is referenced and there is no [RuntimeNameProperty] member, then return Name property in addition.
if (!NameResolver.IsCollectingReferences && xobj.Type.GetAliasedProperty(XamlLanguage.Name) == null)
{
string name = NameResolver.GetReferencedName(xobj, val);
if (name != null)
{
var sobj = new XamlObject(XamlLanguage.String, name);
foreach (var cn in GetMemberNodes(new XamlNodeMember(sobj, XamlLanguage.Name), new [] { new XamlNodeInfo(name) }))
{
yield return(cn);
}
}
}
}
else
{
yield return(new XamlNodeInfo(XamlNodeType.StartObject, xobj));
}
foreach (var xn in GetObjectMemberNodes(xobj))
{
yield return(xn);
}
yield return(new XamlNodeInfo(XamlNodeType.EndObject, xobj));
}
public static IEnumerable <XamlWriterInternalBase.MemberAndValue> GetSortedConstructorArguments(this XamlType type, IList <XamlWriterInternalBase.MemberAndValue> members)
{
var constructors = type.UnderlyingType.GetTypeInfo().GetConstructors();
var preferredParameterCount = 0;
ConstructorInfo preferredConstructor = null;
foreach (var constructor in constructors)
{
var parameters = constructor.GetParameters();
var matchedParameterCount = 0;
bool mismatch = false;
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
var member = members.FirstOrDefault(r => r.Member.ConstructorArgumentName() == parameter.Name);
if (member == null)
{
// allow parameters with a default value to be omitted
mismatch = !parameter.HasDefaultValue();
if (mismatch)
{
break;
}
continue;
}
var paramXamlType = type.SchemaContext.GetXamlType(parameter.ParameterType);
// check if type input type can be converted to the parameter type
mismatch = !paramXamlType.CanConvertFrom(member.Member.Type);
if (mismatch)
{
break;
}
matchedParameterCount++;
}
// prefer the constructor that accepts the most parameters
if (!mismatch && matchedParameterCount > preferredParameterCount)
{
preferredConstructor = constructor;
preferredParameterCount = matchedParameterCount;
}
}
if (preferredConstructor == null)
{
return(null);
}
return(preferredConstructor
.GetParameters()
.Select(p => {
var mem = members.FirstOrDefault(r => r.Member.ConstructorArgumentName() == p.Name);
if (mem == null && p.HasDefaultValue())
{
mem = new XamlWriterInternalBase.MemberAndValue(type.SchemaContext.GetParameter(p));
mem.Value = p.DefaultValue;
}
return mem;
}));
}
// member element, implicit member, children via content property, or value
IEnumerable <XamlXmlNodeInfo> ReadMemberElement(XamlType parentType, XamlType xt)
{
XamlMember xm = null;
var name = r.LocalName;
int idx = name.IndexOf('.');
string typeName = null;
if (idx >= 0)
{
typeName = name.Substring(0, idx);
name = name.Substring(idx + 1);
// check if it is an attachable member first, either of this type or another type
// Should this also check the namespace to find the correct type?
if (typeName == xt.InternalXmlName)
{
xm = xt.GetMember(name);
}
else
{
xm = FindAttachableMember(r.Prefix, typeName, name);
}
}
else
{
xm = (XamlMember)FindStandardDirective(name, AllowedMemberLocations.MemberElement);
if (xm == null)
{
// still not? could it be omitted as content property or items ?
if ((xm = GetExtraMember(xt)) != null)
{
// Note that this does not involve r.Read()
foreach (var ni in ReadMember(xt, xm))
{
yield return(ni);
}
yield break;
}
}
}
if (xm == null)
{
// Current element could be for another member in the parent type (if exists)
if (parentType != null &&
typeName != null &&
typeName == parentType.InternalXmlName &&
parentType.GetMember(name) != null)
{
// stop the iteration and signal the caller to not read current element as an object. (It resolves conflicts between "start object for current collection's item" and "start member for the next member in the parent object".
yield return(Node(XamlNodeType.None, null));
yield break;
}
if (idx >= 0)
{
// Unknown property.
xm = new XamlMember(name, xt, false); // FIXME: not sure if isAttachable is always false.
}
else
{
// Unknown content member.
xm = XamlLanguage.UnknownContent;
foreach (var ni in ReadMember(xt, xm))
{
yield return(ni);
}
yield break;
}
}
if (!r.IsEmptyElement)
{
r.Read();
foreach (var ni in ReadMember(xt, xm))
{
yield return(ni);
}
r.MoveToContent();
r.ReadEndElement();
}
else
{
r.Read();
}
}
protected internal XamlValueConverter <TConverterBase> GetValueConverter <TConverterBase>(Type converterType, XamlType targetType)
where TConverterBase : class
{
#if !HAS_TYPE_CONVERTER
if (typeof(TConverterBase) == typeof(TypeConverter))
{
return(new XamlTypeValueConverter(converterType, targetType) as XamlValueConverter <TConverterBase>);
}
#endif
return(new XamlValueConverter <TConverterBase>(converterType, targetType));
}
public SpecialTypeName(string name, XamlType type)
{
Name = name;
Type = type;
}
public XamlObject(XamlType type, InstanceContext context)
{
this.type = type;
this.context = context;
}
public XamlDuplicateMemberException(XamlMember member, XamlType type)
: this(String.Format("duplicate member '{0}' in type '{1}'", member, type))
{
DuplicateMember = member;
ParentType = type;
}
protected XamlDuplicateMemberException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
DuplicateMember = (XamlMember)info.GetValue("member", typeof(XamlMember));
ParentType = (XamlType)info.GetValue("type", typeof(XamlType));
}
protected internal virtual XamlMember GetParameter(ParameterInfo parameterInfo, XamlType type)
{
var key = new Tuple <MemberInfo, MemberInfo>(parameterInfo.Member, null);
XamlMember member;
if (member_cache.TryGetValue(key, out member))
{
return(member);
}
return(member_cache[key] = new XamlMember(parameterInfo.Name, type, false));
}
public override void WriteStartObject(XamlType type)
{
source.Add(new XamlNodeInfo(XamlNodeType.StartObject, new XamlObject(type, null)));
}
IEnumerable <XamlXmlNodeInfo> ReadMember(XamlType parentType, XamlMember xm)
{
yield return(Node(XamlNodeType.StartMember, xm));
if (xm.IsEvent)
{
yield return(Node(XamlNodeType.Value, r.Value));
r.Read();
}
else if (!xm.IsWritePublic)
{
if (xm.Type.IsXData)
{
foreach (var ni in ReadXData())
{
yield return(ni);
}
}
else if (xm.Type.IsCollection || xm.Type.IsDictionary)
{
yield return(Node(XamlNodeType.GetObject, xm.Type));
yield return(Node(XamlNodeType.StartMember, XamlLanguage.Items));
foreach (var ni in ReadCollectionItems(parentType, XamlLanguage.Items))
{
yield return(ni);
}
yield return(Node(XamlNodeType.EndMember, XamlLanguage.Items));
yield return(Node(XamlNodeType.EndObject, xm.Type));
}
else
{
throw new XamlParseException(String.Format("Read-only member '{0}' showed up in the source XML, and the xml contains element content that cannot be read.", xm.Name))
{
LineNumber = this.LineNumber, LinePosition = this.LinePosition
}
};
}
else
{
if (xm.Type.IsCollection || xm.Type.IsDictionary)
{
foreach (var ni in ReadCollectionItems(parentType, xm))
{
yield return(ni);
}
}
else
{
foreach (var ni in ReadObjectElement(parentType, xm))
{
if (ni.NodeType == XamlNodeType.None)
{
throw new Exception("should not happen");
}
yield return(ni);
}
}
}
yield return(Node(XamlNodeType.EndMember, xm));
}
IEnumerable <XamlNodeInfo> GetNodes(XamlMember xm, XamlObject xobj, XamlType overrideMemberType = null, bool partOfPositionalParameters = false, XamlNodeInfo node = null)
{
//If the item is invisible for the serialization then we must just skip it and return empty nodes info
if (!xobj.Type.ShouldSerialize(xobj.Value))
{
yield break;
}
object val;
// Value - only for non-top-level node (thus xm != null)
if (xm != null)
{
// collection items: each item is exposed as a standalone object that has StartObject, EndObject and contents.
if (ReferenceEquals(xm, XamlLanguage.Items))
{
foreach (var xn in GetItemsNodes(xm, xobj))
{
yield return(xn);
}
yield break;
}
// Arguments: each argument is written as a standalone object
if (ReferenceEquals(xm, XamlLanguage.Arguments))
{
var xarg = new XamlObject();
foreach (var argm in xobj.Type.GetSortedConstructorArguments())
{
var argv = argm.Invoker.GetValue(xobj.Value);
xarg.Set(argm.Type, argv);
foreach (var cn in GetNodes(null, xarg))
{
yield return(cn);
}
}
yield break;
}
// PositionalParameters: items are from constructor arguments, written as Value node sequentially. Note that not all of them are in simple string value. Also, null values are not written as NullExtension
if (ReferenceEquals(xm, XamlLanguage.PositionalParameters))
{
var xarg = new XamlObject();
foreach (var argm in xobj.Type.GetSortedConstructorArguments())
{
foreach (var cn in GetNodes(argm, xarg.Set(argm.Type, xobj.GetMemberValue(argm)), null, true))
{
yield return(cn);
}
}
yield break;
}
node = node ?? new XamlNodeInfo();
if (ReferenceEquals(xm, XamlLanguage.Initialization))
{
yield return(node.Set(TypeExtensionMethods.GetStringValue(xobj.Type, xm, xobj.Value, value_serializer_ctx)));
yield break;
}
val = xobj.Value;
if (xm.DeferringLoader != null)
{
foreach (var xn in GetDeferredNodes(xm, val))
{
yield return(xn);
}
yield break;
}
// don't serialize default values if one is explicitly specified using the DefaultValueAttribute
if (!partOfPositionalParameters)
{
if (xm.Invoker.IsDefaultValue(val))
{
yield break;
}
if (settings.IgnoreDefaultValues && xm.DefaultValue == null)
{
if (xm.Type?.UnderlyingType?.GetTypeInfo().IsValueType == true)
{
if (Equals(val, Activator.CreateInstance(xm.Type.UnderlyingType)))
{
yield break;
}
}
else if (ReferenceEquals(val, null))
{
yield break;
}
}
}
// overrideMemberType is (so far) used for XamlLanguage.Key.
var xtt = overrideMemberType ?? xm.Type;
if (!xtt.IsMarkupExtension && // this condition is to not serialize MarkupExtension whose type has TypeConverterAttribute (e.g. StaticExtension) as a string.
(xtt.IsContentValue(value_serializer_ctx) || xm.IsContentValue(value_serializer_ctx)))
{
// though null value is special: it is written as a standalone object.
if (val == null)
{
if (!partOfPositionalParameters)
{
foreach (var xn in GetNodes(null, null_object, node: node))
{
yield return(xn);
}
}
else
{
yield return(node.Set(String.Empty));
}
}
else if (!NameResolver.IsCollectingReferences) // for perf, getting string value can be expensive
{
yield return(node.Set(TypeExtensionMethods.GetStringValue(xtt, xm, val, value_serializer_ctx)));
}
else if (val is Type)
{
LookupType((Type)val);
}
//new XamlTypeName(xtt.SchemaContext.GetXamlType((Type)val)).ToString(value_serializer_ctx?.GetService(typeof(INamespacePrefixLookup)) as INamespacePrefixLookup);
yield break;
}
// collection items: return GetObject and Items.
if ((xm.Type.IsCollection || xm.Type.IsDictionary) && !xm.IsWritePublic)
{
yield return(XamlNodeInfo.GetObject);
// Write Items member only when there are items (i.e. do not write it if it is empty).
var itemsValue = xobj.GetMemberObjectValue(XamlLanguage.Items);
var en = GetItemsNodes(XamlLanguage.Items, itemsValue).GetEnumerator();
if (en.MoveNext())
{
yield return(node.Set(XamlNodeType.StartMember, XamlLanguage.Items));
do
{
yield return(en.Current);
} while (en.MoveNext());
yield return(XamlNodeInfo.EndMember);
}
yield return(XamlNodeInfo.EndObject);
yield break;
}
if (xm.Type.IsXData)
{
var sw = new StringWriter();
var xw = XmlWriter.Create(sw, new XmlWriterSettings {
OmitXmlDeclaration = true, ConformanceLevel = ConformanceLevel.Auto
});
#if NETSTANDARD1_0
if (!ReflectionHelpers.IXmlSerializableType?.GetTypeInfo().IsAssignableFrom(val?.GetType().GetTypeInfo()) ?? false)
{
yield break; // do not output anything
}
ReflectionHelpers.IXmlSerializableWriteXmlMethod?.Invoke(val, new object[] { xw });
#else
var val3 = val as IXmlSerializable;
if (val3 == null)
{
yield break; // do not output anything
}
val3.WriteXml(xw);
#endif
xw.Dispose();
var obj = new XData {
Text = sw.ToString()
};
foreach (var xn in GetNodes(null, new XamlObject(XamlLanguage.XData, obj), node: node))
{
yield return(xn);
}
yield break;
}
}
else
{
node = node ?? new XamlNodeInfo();
val = xobj.Value;
}
// Object - could become Reference
if (val != null && !ReferenceEquals(xobj.Type, XamlLanguage.Reference))
{
if (xm != null && !xm.IsReadOnly && !IsPublicOrVisible(val.GetType()))
{
throw new XamlObjectReaderException($"Cannot read from internal type {xobj.Type}");
}
if (!xobj.Type.IsContentValue(value_serializer_ctx))
{
string refName = NameResolver.GetReferenceName(xobj, val);
if (refName != null)
{
// The target object is already retrieved, so we don't return the same object again.
NameResolver.SaveAsReferenced(val); // Record it as named object.
// Then return Reference object instead.
var xref = new XamlObject(XamlLanguage.Reference, new Reference(refName));
yield return(node.Set(XamlNodeType.StartObject, xref));
yield return(node.Set(XamlNodeType.StartMember, XamlLanguage.PositionalParameters));
yield return(node.Set(refName));
yield return(XamlNodeInfo.EndMember);
yield return(XamlNodeInfo.EndObject);
yield break;
}
else
{
// The object appeared in the xaml tree for the first time. So we store the reference with a unique name so that it could be referenced later.
NameResolver.SetNamedObject(val, true); // probably fullyInitialized is always true here.
}
}
yield return(node.Set(XamlNodeType.StartObject, xobj));
// If this object is referenced and there is no [RuntimeNameProperty] member, then return Name property in addition.
if (!NameResolver.IsCollectingReferences && xobj.Type.GetAliasedProperty(XamlLanguage.Name) == null)
{
string name = NameResolver.GetReferencedName(xobj, val);
if (name != null)
{
yield return(node.Set(XamlNodeType.StartMember, XamlLanguage.Name));
yield return(node.Set(name));
yield return(XamlNodeInfo.EndMember);
}
}
}
else
{
yield return(node.Set(XamlNodeType.StartObject, xobj));
}
// get all object member nodes
var xce = GetNodeMembers(xobj, value_serializer_ctx).GetEnumerator();
var xobject = new XamlObject();
var startNode = new XamlNodeInfo();
while (xce.MoveNext())
{
var xnm = xce.Current;
var en = GetNodes(xnm.Member, xnm.GetValue(xobject), node: node).GetEnumerator();
if (en.MoveNext())
{
if (!xnm.Member.IsWritePublic && xnm.Member.Type != null && (xnm.Member.Type.IsCollection || xnm.Member.Type.IsDictionary))
{
// if we are a collection or dictionary without a setter, check to see if its empty first
var node1 = en.Current.Copy(); // getObject
if (!en.MoveNext())
{
continue;
}
var node2 = en.Current.Copy(); // possibly endObject
if (!en.MoveNext()) // we have one more, so it's not empty!
{
continue;
}
// if we have three nodes, then it isn't empty
yield return(startNode.Set(XamlNodeType.StartMember, xnm.Member));
yield return(node1);
yield return(node2);
}
else
{
yield return(startNode.Set(XamlNodeType.StartMember, xnm.Member));
}
do
{
yield return(en.Current);
} while (en.MoveNext());
yield return(XamlNodeInfo.EndMember);
}
}
yield return(XamlNodeInfo.EndObject);
}
public XamlObject(XamlType type, object instance)
: this(type, new InstanceContext(instance))
{
}
// Note that it could return invalid (None) node to tell the caller that it is not really an object element.
IEnumerable <XamlXmlNodeInfo> ReadObjectElement(XamlType parentType, XamlMember currentMember)
{
if (r.NodeType == XmlNodeType.Whitespace)
{
r.MoveToContent();
}
if (r.NodeType == XmlNodeType.EndElement)
{
yield break;
}
if (r.NodeType != XmlNodeType.Element)
{
throw new XamlParseException(String.Format("Element is expected, but got {0}", r.NodeType));
}
if (r.MoveToFirstAttribute())
{
do
{
if (r.NamespaceURI == XamlLanguage.Xmlns2000Namespace)
{
yield return(Node(XamlNodeType.NamespaceDeclaration, new NamespaceDeclaration(ResolveLocalNamespace(r.Value), r.Prefix == "xmlns" ? r.LocalName : String.Empty)));
}
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
var sti = GetStartTagInfo();
var xt = sctx.GetXamlType(sti.TypeName);
if (ReferenceEquals(xt, null))
{
// Current element could be for another member in the parent type (if exists)
if (parentType != null && (r.LocalName.IndexOf('.') > 0 || parentType.GetMember(r.LocalName) != null))
{
// stop the iteration and signal the caller to not read current element as an object. (It resolves conflicts between "start object for current collection's item" and "start member for the next member in the parent object".
yield return(Node(XamlNodeType.None, null));
yield break;
}
// creates name-only XamlType. Also, it does not seem that it does not store this XamlType to XamlSchemaContext (Try GetXamlType(xtn) after reading such xaml node, it will return null).
xt = new XamlType(sti.Namespace, sti.Name, sti.TypeName.TypeArguments?.Select(xxtn => sctx.GetXamlType(xxtn)).ToArray(), sctx);
}
// It could still be GetObject if current_member is not defer-loaded, it
// is not a directive, and current type is not
// a markup extension.
// (I'm not very sure about the condition;
// it could be more complex.)
// seealso: bug #682131
if (!ReferenceEquals(currentMember, null) &&
ReferenceEquals(currentMember.DeferringLoader, null) &&
!xt.CanAssignTo(currentMember.Type) &&
!ReferenceEquals(xt, XamlLanguage.Reference) &&
(
currentMember.DeclaringType?.ContentProperty == currentMember ||
(!currentMember.IsDirective && !xt.IsMarkupExtension)
)
)
{
yield return(Node(XamlNodeType.GetObject, currentMember.Type));
foreach (var ni in ReadMembers(parentType, currentMember.Type))
{
yield return(ni);
}
yield return(Node(XamlNodeType.EndObject, currentMember.Type));
yield break;
}
yield return(Node(XamlNodeType.StartObject, xt));
// process attribute members (including MarkupExtensions)
ProcessAttributesToMember(sti, xt);
for (int i = 0; i < sti.Members.Count; i++)
{
var memberInfo = sti.Members[i];
yield return(Node(XamlNodeType.StartMember, memberInfo.Member, memberInfo.LineInfo));
// Try markup extension
// FIXME: is this rule correct?
var v = memberInfo.Value;
if (!string.IsNullOrEmpty(v) && v[0] == '{')
{
if (v.Length >= 2 && v[1] == '}')
{
// escaped value with {} at the beginning of the string
yield return(Node(XamlNodeType.Value, v.Substring(2)));
}
else
{
var pai = new ParsedMarkupExtensionInfo(v, xaml_namespace_resolver, sctx);
pai.Parse();
foreach (var node in ReadMarkup(pai))
{
yield return(node);
}
}
}
else
{
yield return(Node(XamlNodeType.Value, v));
}
yield return(Node(XamlNodeType.EndMember, memberInfo.Member));
}
// process content members
if (!r.IsEmptyElement)
{
r.Read();
foreach (var ni in ReadMembers(parentType, xt))
{
yield return(ni);
}
r.ReadEndElement();
}
else
{
r.Read(); // consume empty element.
}
yield return(Node(XamlNodeType.EndObject, xt));
}
public abstract void WriteStartObject(XamlType type);
IEnumerable <XamlXmlNodeInfo> ReadCollectionItems(XamlType parentType, XamlMember xm)
{
bool GetNextElementTrim()
{
if (r.NodeType == XmlNodeType.Element)
{
var sti = GetStartTagInfo();
var xt = sctx.GetXamlType(sti.TypeName);
return(xt.TrimSurroundingWhitespace);
}
return(true);
}
XamlTypeName previous = null;
r.MoveToContent();
while (r.NodeType != XmlNodeType.EndElement)
{
switch (r.NodeType)
{
case XmlNodeType.Text:
var text = r.Value;
r.Read();
var trimStart = previous == null ||
sctx.GetXamlType(previous).TrimSurroundingWhitespace;
var trimEnd = r.NodeType == XmlNodeType.EndElement ||
GetNextElementTrim();
yield return(Node(XamlNodeType.Value, NormalizeWhitespace(text, trimStart, trimEnd)));
break;
case XmlNodeType.Element:
if (parentType != null && (r.LocalName.IndexOf('.') > 0 || parentType.GetMember(r.LocalName) != null))
{
yield return(Node(XamlNodeType.None, null));
yield break;
}
var sti = GetStartTagInfo();
previous = sti.TypeName;
foreach (var x in ReadObjectElement(parentType, xm))
{
yield return(x);
}
break;
case XmlNodeType.Whitespace:
r.Read();
if (previous != null &&
parentType.IsWhitespaceSignificantCollection &&
!sctx.GetXamlType(previous).TrimSurroundingWhitespace)
{
if (r.NodeType != XmlNodeType.EndElement)
{
yield return(Node(XamlNodeType.Value, " "));
}
}
break;
default:
throw new XamlParseException(String.Format("Text or Element is expected, but got {0}", r.NodeType));
}
}
}
public static IEnumerable <XamlMember> GetSortedConstructorArguments(this XamlType type, IList <object> contents = null)
{
var constructors = type.UnderlyingType.GetTypeInfo().GetConstructors();
if (contents != null && contents.Count > 0)
{
// find constructor based on supplied parameters
foreach (var constructor in constructors)
{
var parameters = constructor.GetParameters();
if (contents.Count > parameters.Length)
{
continue;
}
bool mismatch = false;
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
if (i >= contents.Count)
{
// allow parameters with a default value to be omitted
mismatch = !parameter.HasDefaultValue();
if (mismatch)
{
break;
}
continue;
}
// check if the parameter value can be assigned to the required type
var posParameter = contents[i];
var paramXamlType = type.SchemaContext.GetXamlType(parameter.ParameterType);
// check if type input type can be converted to the parameter type
var inputType = posParameter == null ? XamlLanguage.Null : type.SchemaContext.GetXamlType(posParameter.GetType());
mismatch = !paramXamlType.CanConvertFrom(inputType);
if (mismatch)
{
break;
}
}
if (mismatch)
{
continue;
}
// matches constructor arguments
return(constructor
.GetParameters()
.Select(p => type.SchemaContext.GetParameter(p)));
}
}
// find constructor based on ConstructorArgumentAttribute
var args = type.GetConstructorArguments();
foreach (var ci in constructors)
{
var pis = ci.GetParameters();
if (args.Count != pis.Length)
{
continue;
}
bool mismatch = false;
foreach (var pi in pis)
{
for (int i = 0; i < args.Count; i++)
{
mismatch |= args.All(a => a.ConstructorArgumentName() != pi.Name);
}
}
if (mismatch)
{
continue;
}
return(args.OrderBy(c => pis.FindParameterWithName(c.ConstructorArgumentName()).Position));
}
return(null);
}
protected internal XamlValueConverter <TConverterBase> GetValueConverter <TConverterBase>(Type converterType, XamlType targetType)
where TConverterBase : class
{
return(new XamlValueConverter <TConverterBase>(converterType, targetType));
}
// Note that it could return invalid (None) node to tell the caller that it is not really an object element.
IEnumerable <XamlXmlNodeInfo> ReadObjectElement(XamlType parentType, XamlMember currentMember)
{
if (r.NodeType == XmlNodeType.EndElement)
{
yield break;
}
if (r.NodeType == XmlNodeType.Text || r.NodeType == XmlNodeType.CDATA)
{
//throw new XamlParseException (String.Format ("Element is expected, but got {0}", r.NodeType));
yield return(Node(XamlNodeType.Value, r.Value));
r.Read();
yield break;
}
if (r.NodeType != XmlNodeType.Element)
{
throw new XamlParseException(String.Format("Element is expected, but got {0}", r.NodeType));
}
if (r.MoveToFirstAttribute())
{
do
{
if (r.NamespaceURI == XamlLanguage.Xmlns2000Namespace)
{
yield return(Node(XamlNodeType.NamespaceDeclaration, new NamespaceDeclaration(ResolveLocalNamespace(r.Value), r.Prefix == "xmlns" ? r.LocalName : String.Empty)));
}
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
var sti = GetStartTagInfo();
var xt = sctx.GetXamlType(sti.TypeName);
if (xt == null)
{
// Current element could be for another member in the parent type (if exists)
if (parentType != null && (r.LocalName.IndexOf('.') > 0 || parentType.GetMember(r.LocalName) != null))
{
// stop the iteration and signal the caller to not read current element as an object. (It resolves conflicts between "start object for current collection's item" and "start member for the next member in the parent object".
yield return(Node(XamlNodeType.None, null));
yield break;
}
// creates name-only XamlType. Also, it does not seem that it does not store this XamlType to XamlSchemaContext (Try GetXamlType(xtn) after reading such xaml node, it will return null).
xt = new XamlType(sti.Namespace, sti.Name, sti.TypeName.TypeArguments == null ? null : sti.TypeName.TypeArguments.Select <XamlTypeName, XamlType> (xxtn => sctx.GetXamlType(xxtn)).ToArray(), sctx);
}
bool isGetObject = false;
if (currentMember != null && !xt.CanAssignTo(currentMember.Type))
{
if (currentMember.DeclaringType != null && currentMember.DeclaringType.ContentProperty == currentMember)
{
isGetObject = true;
}
// It could still be GetObject if current_member
// is not a directive and current type is not
// a markup extension.
// (I'm not very sure about the condition;
// it could be more complex.)
// seealso: bug #682131
else if (!(currentMember is XamlDirective) &&
!xt.IsMarkupExtension)
{
isGetObject = true;
}
}
if (isGetObject)
{
yield return(Node(XamlNodeType.GetObject, currentMember.Type));
foreach (var ni in ReadMembers(parentType, currentMember.Type))
{
yield return(ni);
}
yield return(Node(XamlNodeType.EndObject, currentMember.Type));
yield break;
}
// else
yield return(Node(XamlNodeType.StartObject, xt));
// process attribute members (including MarkupExtensions)
ProcessAttributesToMember(sti, xt);
foreach (var pair in sti.Members)
{
yield return(Node(XamlNodeType.StartMember, pair.Key));
// Try markup extension
// FIXME: is this rule correct?
var v = pair.Value;
if (!String.IsNullOrEmpty(v) && v [0] == '{')
{
var pai = new ParsedMarkupExtensionInfo(v, xaml_namespace_resolver, sctx);
pai.Parse();
foreach (var node in ReadMarkup(pai))
{
yield return(node);
}
}
else
{
yield return(Node(XamlNodeType.Value, pair.Value));
}
yield return(Node(XamlNodeType.EndMember, pair.Key));
}
// process content members
if (!r.IsEmptyElement)
{
r.Read();
foreach (var ni in ReadMembers(parentType, xt))
{
yield return(ni);
}
r.ReadEndElement();
}
else
{
r.Read(); // consume empty element.
}
yield return(Node(XamlNodeType.EndObject, xt));
}
