// Namespace and Reference retrieval. // It is iterated before iterating the actual object nodes, // and results are cached for use in XamlObjectReader. public void PrepareReading() { PrefixLookup.IsCollectingNamespaces = true; NameResolver.IsCollectingReferences = true; foreach (var xn in GetNodes()) { if (xn.NodeType == XamlNodeType.GetObject) { continue; // it is out of consideration here. } if (xn.NodeType == XamlNodeType.StartObject) { foreach (var ns in NamespacesInType(xn.Object.Type)) { PrefixLookup.LookupPrefix(ns); } } else if (xn.NodeType == XamlNodeType.StartMember) { var xm = xn.Member.Member; // This filtering is done as a black list so far. There does not seem to be any usable property on XamlDirective. if (xm == XamlLanguage.Items || xm == XamlLanguage.PositionalParameters || xm == XamlLanguage.Initialization) { continue; } PrefixLookup.LookupPrefix(xn.Member.Member.PreferredXamlNamespace); } else { if (xn.NodeType == XamlNodeType.Value && xn.Value is Type) { // this tries to lookup existing prefix, and if there isn't any, then adds a new declaration. TypeExtensionMethods.GetStringValue(XamlLanguage.Type, xn.Member.Member, xn.Value, value_serializer_ctx); } continue; } } PrefixLookup.Namespaces.Sort((nd1, nd2) => String.CompareOrdinal(nd1.Prefix, nd2.Prefix)); PrefixLookup.IsCollectingNamespaces = false; NameResolver.IsCollectingReferences = false; NameResolver.NameScopeInitializationCompleted(this); }
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); }
IEnumerable <XamlNodeInfo> GetNodes(XamlMember xm, XamlObject xobj, XamlType overrideMemberType, bool partOfPositionalParameters) { // 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; } // Value - only for non-top-level node (thus xm != null) if (xm != null) { // 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. var val = xobj.GetRawValue(); 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 != null && 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)); } else if (xm != null && xm.Type.IsXData) { var sw = new StringWriter(); var xw = XmlWriter.Create(sw, new XmlWriterSettings() { OmitXmlDeclaration = true, ConformanceLevel = ConformanceLevel.Auto }); var val = xobj.GetRawValue() as IXmlSerializable; if (val == null) { yield break; // do not output anything } val.WriteXml(xw); xw.Close(); var obj = new XData() { Text = sw.ToString() }; foreach (var xn in GetNodes(null, new XamlObject(XamlLanguage.XData, obj))) { yield return(xn); } } else { // Object - could become Reference var val = xobj.GetRawValue(); if (!xobj.Type.IsContentValue(value_serializer_ctx) && val != null) { string refName = NameResolver.GetName(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. refName = GetReferenceName(xobj); if (NameResolver.IsCollectingReferences && NameResolver.Contains(refName)) { throw new InvalidOperationException(String.Format("There is already an object of type {0} named as '{1}'. Object names must be unique.", val.GetType(), refName)); } NameResolver.SetNamedObject(refName, 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 (val != null && xobj.Type.GetAliasedProperty(XamlLanguage.Name) == null) { string name = NameResolver.GetReferencedName(val); if (name != null) { var sobj = new XamlObject(XamlLanguage.String, name); foreach (var cn in GetMemberNodes(new XamlNodeMember(sobj, XamlLanguage.Name), new XamlNodeInfo [] { new XamlNodeInfo(name) })) { yield return(cn); } } } foreach (var xn in GetObjectMemberNodes(xobj)) { yield return(xn); } yield return(new XamlNodeInfo(XamlNodeType.EndObject, xobj)); } }