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));
}
// 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 (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 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) &&
!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 pair = sti.Members[i];
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] == '{')
{
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, 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));
}
// 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;
}
// ok, then create unknown member.
xm = new XamlMember(name, xt, false); // FIXME: not sure if isAttachable is always false.
}
if (!r.IsEmptyElement)
{
r.Read();
foreach (var ni in ReadMember(xt, xm))
{
yield return(ni);
}
r.MoveToContent();
r.ReadEndElement();
}
else
{
r.Read();
}
}
IEnumerable <XamlNodeInfo> GetNodes(XamlMember xm, XamlObject xobj)
{
return(GetNodes(xm, xobj, null, false));
}
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 abstract void WriteStartMember(XamlMember xamlMember);
internal static ICustomAttributeProvider GetCustomAttributeProvider(this XamlMember member)
{
return(member.UnderlyingMember);
}
internal static string GetInternalXmlName(this XamlMember xm)
{
return(xm.IsAttachable ? String.Concat(xm.DeclaringType.InternalXmlName, ".", xm.Name) : xm.Name);
}
internal static int CompareMembers(XamlMember m1, XamlMember m2)
{
if (ReferenceEquals(m1, null))
{
return(ReferenceEquals(m2, null) ? 0 : -1);
}
if (ReferenceEquals(m2, null))
{
return(1);
}
// these come before non-content properties
// 1. PositionalParameters comes first
if (ReferenceEquals(m1, XamlLanguage.PositionalParameters))
{
return(ReferenceEquals(m2, XamlLanguage.PositionalParameters) ? 0 : -1);
}
if (ReferenceEquals(m2, XamlLanguage.PositionalParameters))
{
return(1);
}
// 2. constructor arguments
if (m1.IsConstructorArgument)
{
if (!m2.IsConstructorArgument)
{
return(-1);
}
}
else if (m2.IsConstructorArgument)
{
return(1);
}
// these come AFTER non-content properties
// 1. initialization
if (ReferenceEquals(m1, XamlLanguage.Initialization))
{
return(ReferenceEquals(m2, XamlLanguage.Initialization) ? 0 : 1);
}
if (ReferenceEquals(m2, XamlLanguage.Initialization))
{
return(-1);
}
// 2. key
if (ReferenceEquals(m1, XamlLanguage.Key))
{
return(ReferenceEquals(m2, XamlLanguage.Key) ? 0 : 1);
}
if (ReferenceEquals(m2, XamlLanguage.Key))
{
return(-1);
}
// 3. Name
if (ReferenceEquals(m1, XamlLanguage.Name))
{
return(ReferenceEquals(m2, XamlLanguage.Name) ? 0 : 1);
}
if (ReferenceEquals(m2, XamlLanguage.Name))
{
return(-1);
}
// 4. Properties that (probably) require a child node should come last so we can
// put as many in the start tag as possible.
if (m1.RequiresChildNode)
{
if (!m2.RequiresChildNode)
{
return(1);
}
}
else if (m2.RequiresChildNode)
{
return(-1);
}
// then, compare names.
return(String.CompareOrdinal(m1.Name, m2.Name));
}
public static string ConstructorArgumentName(this XamlMember xm)
{
var caa = xm.CustomAttributeProvider.GetCustomAttribute <ConstructorArgumentAttribute> (false);
return(caa.ArgumentName);
}
