private void ValidateMemberOnType(XamlMember member, XamlType type) { if (member.IsUnknown || type.IsUnknown) { return; } if (member.IsDirective) { if (member == XamlLanguage.Items) { if (!type.IsCollection && !type.IsDictionary) { ValidationError(SR.UnexpectedXamlDictionary(member.Name, GetXamlTypeName(_stack.TopFrame.Type))); } } if (member == XamlLanguage.Class && _stack.Depth > 1) { ValidationError(SR.UnexpectedXamlClass); } } else if (member.IsAttachable) { if (!type.CanAssignTo(member.TargetType)) { ValidationError(SR.UnexpectedXamlAttachableMember(member.Name, GetXamlTypeName(member.TargetType))); } } else if (!member.IsDirective && !type.CanAssignTo(member.DeclaringType)) { ValidationError(SR.UnexpectedXamlMemberNotAssignable(member.Name, GetXamlTypeName(type))); } }
/// <SecurityNote> /// Because this is a public virtual method, idempotence cannot be guaranteed. /// S.X doesn't use this method at all; but any externals consumers who are doing security checks /// based on the returned method should make sure that they are resillient to changing results. /// </SecurityNote> public virtual MethodInfo GetAddMethod(XamlType contentType) { if (contentType == null) { throw new ArgumentNullException(nameof(contentType)); } if (IsUnknown || _xamlType.ItemType == null) { return(null); } // Common case is that we match the item type. Short-circuit any additional lookup. if (contentType == _xamlType.ItemType || (_xamlType.AllowedContentTypes.Count == 1 && contentType.CanAssignTo(_xamlType.ItemType))) { return(_xamlType.AddMethod); } // Only collections can have additional content types if (!_xamlType.IsCollection) { return(null); } // Populate the dictionary of all available Add methods MethodInfo addMethod; if (_addMethods == null) { Dictionary <XamlType, MethodInfo> addMethods = new Dictionary <XamlType, MethodInfo>(); addMethods.Add(_xamlType.ItemType, _xamlType.AddMethod); foreach (XamlType type in _xamlType.AllowedContentTypes) { addMethod = CollectionReflector.GetAddMethod( _xamlType.UnderlyingType, type.UnderlyingType); if (addMethod != null) { addMethods.Add(type, addMethod); } } _addMethods = addMethods; } // First try the fast path. Look for an exact match. if (_addMethods.TryGetValue(contentType, out addMethod)) { return(addMethod); } // Next the slow path. Check each one for is assignable from. foreach (KeyValuePair <XamlType, MethodInfo> pair in _addMethods) { if (contentType.CanAssignTo(pair.Key)) { return(pair.Value); } } return(null); }
private void ValidateTypeToMemberOnStack(XamlType type) { if (type.IsUnknown) { return; } if (type == this.xNull) { ValidateValueToMemberOnStack(null); } XamlMember member = _stack.TopFrame.Member; if (member == XamlLanguage.PositionalParameters || type.IsMarkupExtension || member.IsUnknown) { return; } if (member == XamlLanguage.Items) { XamlType collectionType = GetCollectionTypeOnStack(); if (collectionType == null || collectionType.IsUnknown || collectionType.AllowedContentTypes == null) { return; } if (!collectionType.AllowedContentTypes.Any(contentType => type.CanAssignTo(contentType))) { ValidationError(SR.UnassignableCollection(GetXamlTypeName(type), GetXamlTypeName(collectionType.ItemType), GetXamlTypeName(collectionType))); } } else if (member.IsDirective && (member.Type.IsCollection || member.Type.IsDictionary)) { XamlType collectionType = member.Type; if (collectionType == null || collectionType.IsUnknown || collectionType.AllowedContentTypes == null) { return; } if (!collectionType.AllowedContentTypes.Any(contentType => type.CanAssignTo(contentType))) { ValidationError(SR.UnassignableCollection(GetXamlTypeName(type), GetXamlTypeName(collectionType.ItemType), GetXamlTypeName(collectionType))); } } else if (!type.CanAssignTo(member.Type)) { if (member.DeferringLoader != null) { return; } if (NodeType == XamlNodeType.Value) { ValidationError(SR.UnassignableTypes(GetXamlTypeName(type), GetXamlTypeName(member.Type), member.Name)); } else { ValidationError(SR.UnassignableTypesObject(GetXamlTypeName(type), GetXamlTypeName(member.Type), member.Name)); } } }
public XamlMember GetDottedProperty(XamlType tagType, string tagNamespace, XamlPropertyName propName, bool tagIsRoot) { if (tagType == null) { throw new XamlInternalException(System.Xaml.SR.Get("ParentlessPropertyElement", new object[] { propName.ScopedName })); } XamlMember xamlAttachableProperty = null; XamlType xamlType = null; string propNs = this.ResolveXamlNameNS(propName); if (propNs == null) { throw new XamlParseException(System.Xaml.SR.Get("PrefixNotFound", new object[] { propName.Prefix })); } XamlType rootTagType = tagIsRoot ? tagType : null; bool flag = false; if (tagType.IsGeneric) { flag = this.PropertyTypeMatchesGenericTagType(tagType, tagNamespace, propNs, propName.OwnerName); if (flag) { xamlAttachableProperty = this.GetInstanceOrAttachableProperty(tagType, propName.Name, rootTagType); if (xamlAttachableProperty != null) { return(xamlAttachableProperty); } } } XamlTypeName typeName = new XamlTypeName(propNs, propName.Owner.Name); xamlType = this.GetXamlType(typeName, true); bool flag2 = tagType.CanAssignTo(xamlType); if (flag2) { xamlAttachableProperty = this.GetInstanceOrAttachableProperty(xamlType, propName.Name, rootTagType); } else { xamlAttachableProperty = this.GetXamlAttachableProperty(xamlType, propName.Name); } if (xamlAttachableProperty != null) { return(xamlAttachableProperty); } XamlType declaringType = flag ? tagType : xamlType; if (flag || flag2) { return(this.CreateUnknownMember(declaringType, propName.Name)); } return(this.CreateUnknownAttachableMember(declaringType, propName.Name)); }
bool IsAssignableTo(XamlType type, Type assignableTo) { XamlType liveXamlType = this.schemaContext.GetXamlType(assignableTo); XamlType rolXamlType = this.schemaContext.GetXamlType(new XamlTypeName(liveXamlType)); if (rolXamlType == null) { // assignableTo is not in the project references, so project must not be deriving from it return(false); } return(type.CanAssignTo(rolXamlType)); }
public XamlMember GetDottedProperty(XamlType tagType, string tagNamespace, XamlPropertyName propName, bool tagIsRoot) { if (tagType == null) { throw new XamlInternalException(System.Xaml.SR.Get("ParentlessPropertyElement", new object[] { propName.ScopedName })); } XamlMember xamlAttachableProperty = null; XamlType xamlType = null; string propNs = this.ResolveXamlNameNS(propName); if (propNs == null) { throw new XamlParseException(System.Xaml.SR.Get("PrefixNotFound", new object[] { propName.Prefix })); } XamlType rootTagType = tagIsRoot ? tagType : null; bool flag = false; if (tagType.IsGeneric) { flag = this.PropertyTypeMatchesGenericTagType(tagType, tagNamespace, propNs, propName.OwnerName); if (flag) { xamlAttachableProperty = this.GetInstanceOrAttachableProperty(tagType, propName.Name, rootTagType); if (xamlAttachableProperty != null) { return xamlAttachableProperty; } } } XamlTypeName typeName = new XamlTypeName(propNs, propName.Owner.Name); xamlType = this.GetXamlType(typeName, true); bool flag2 = tagType.CanAssignTo(xamlType); if (flag2) { xamlAttachableProperty = this.GetInstanceOrAttachableProperty(xamlType, propName.Name, rootTagType); } else { xamlAttachableProperty = this.GetXamlAttachableProperty(xamlType, propName.Name); } if (xamlAttachableProperty != null) { return xamlAttachableProperty; } XamlType declaringType = flag ? tagType : xamlType; if (flag || flag2) { return this.CreateUnknownMember(declaringType, propName.Name); } return this.CreateUnknownAttachableMember(declaringType, propName.Name); }
public virtual MethodInfo GetAddMethod(XamlType contentType) { if (contentType == null) { throw new ArgumentNullException("contentType"); } if (!this.IsUnknown && (this._xamlType.ItemType != null)) { MethodInfo addMethod; if ((contentType == this._xamlType.ItemType) || ((this._xamlType.AllowedContentTypes.Count == 1) && contentType.CanAssignTo(this._xamlType.ItemType))) { return(this._xamlType.AddMethod); } if (!this._xamlType.IsCollection) { return(null); } if (this._addMethods == null) { Dictionary <XamlType, MethodInfo> dictionary = new Dictionary <XamlType, MethodInfo>(); dictionary.Add(this._xamlType.ItemType, this._xamlType.AddMethod); foreach (XamlType type in this._xamlType.AllowedContentTypes) { addMethod = CollectionReflector.GetAddMethod(this._xamlType.UnderlyingType, type.UnderlyingType); if (addMethod != null) { dictionary.Add(type, addMethod); } } this._addMethods = dictionary; } if (this._addMethods.TryGetValue(contentType, out addMethod)) { return(addMethod); } foreach (KeyValuePair <XamlType, MethodInfo> pair in this._addMethods) { if (contentType.CanAssignTo(pair.Key)) { return(pair.Value); } } } return(null); }
internal XamlMember GetProperty(Int16 propertyId, XamlType parentType) { BamlProperty bamlProperty; XamlMember xamlMember; if (TryGetBamlProperty(propertyId, out bamlProperty, out xamlMember)) { if (xamlMember != null) { return(xamlMember); } XamlType declaringType = GetXamlType(bamlProperty.DeclaringTypeId); // If the parent type & declaring type are assignable, then it could // be either a regular property or attachable. if (parentType.CanAssignTo(declaringType)) { xamlMember = declaringType.GetMember(bamlProperty.Name); if (xamlMember == null) { xamlMember = declaringType.GetAttachableMember(bamlProperty.Name); } } else { //If not assignable, it has to be an attachable member xamlMember = declaringType.GetAttachableMember(bamlProperty.Name); } lock (_syncObject) { _bamlProperty[propertyId] = xamlMember; } return(xamlMember); } throw new KeyNotFoundException(); }
// Token: 0x0600226B RID: 8811 RVA: 0x000AAF38 File Offset: 0x000A9138 internal static void TransformNodes(XamlReader xamlReader, XamlObjectWriter xamlWriter, bool onlyLoadOneNode, bool skipJournaledProperties, bool shouldPassLineNumberInfo, IXamlLineInfo xamlLineInfo, IXamlLineInfoConsumer xamlLineInfoConsumer, XamlContextStack <WpfXamlFrame> stack, IStyleConnector styleConnector) { while (xamlReader.Read()) { if (shouldPassLineNumberInfo && xamlLineInfo.LineNumber != 0) { xamlLineInfoConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition); } switch (xamlReader.NodeType) { case XamlNodeType.StartObject: WpfXamlLoader.WriteStartObject(xamlReader, xamlWriter, stack); break; case XamlNodeType.GetObject: xamlWriter.WriteNode(xamlReader); if (stack.CurrentFrame.Type != null) { stack.PushScope(); } stack.CurrentFrame.Type = stack.PreviousFrame.Property.Type; break; case XamlNodeType.EndObject: { xamlWriter.WriteNode(xamlReader); if (stack.CurrentFrame.FreezeFreezable) { Freezable freezable = xamlWriter.Result as Freezable; if (freezable != null && freezable.CanFreeze) { freezable.Freeze(); } } DependencyObject dependencyObject = xamlWriter.Result as DependencyObject; if (dependencyObject != null && stack.CurrentFrame.XmlSpace != null) { XmlAttributeProperties.SetXmlSpace(dependencyObject, stack.CurrentFrame.XmlSpace.Value ? "default" : "preserve"); } stack.PopScope(); break; } case XamlNodeType.StartMember: if ((!xamlReader.Member.IsDirective || !(xamlReader.Member == XamlReaderHelper.Freeze)) && xamlReader.Member != WpfXamlLoader.XmlSpace.Value && xamlReader.Member != XamlLanguage.Space) { xamlWriter.WriteNode(xamlReader); } stack.CurrentFrame.Property = xamlReader.Member; if (skipJournaledProperties && !stack.CurrentFrame.Property.IsDirective) { WpfXamlMember wpfXamlMember = stack.CurrentFrame.Property as WpfXamlMember; if (wpfXamlMember != null) { DependencyProperty dependencyProperty = wpfXamlMember.DependencyProperty; if (dependencyProperty != null) { FrameworkPropertyMetadata frameworkPropertyMetadata = dependencyProperty.GetMetadata(stack.CurrentFrame.Type.UnderlyingType) as FrameworkPropertyMetadata; if (frameworkPropertyMetadata != null && frameworkPropertyMetadata.Journal) { int num = 1; while (xamlReader.Read()) { switch (xamlReader.NodeType) { case XamlNodeType.StartObject: { XamlType type = xamlReader.Type; XamlType xamlType = type.SchemaContext.GetXamlType(typeof(BindingBase)); XamlType xamlType2 = type.SchemaContext.GetXamlType(typeof(DynamicResourceExtension)); if (num == 1 && (type.CanAssignTo(xamlType) || type.CanAssignTo(xamlType2))) { num = 0; WpfXamlLoader.WriteStartObject(xamlReader, xamlWriter, stack); } break; } case XamlNodeType.StartMember: num++; break; case XamlNodeType.EndMember: num--; if (num == 0) { xamlWriter.WriteNode(xamlReader); stack.CurrentFrame.Property = null; } break; case XamlNodeType.Value: { DynamicResourceExtension dynamicResourceExtension = xamlReader.Value as DynamicResourceExtension; if (dynamicResourceExtension != null) { WpfXamlLoader.WriteValue(xamlReader, xamlWriter, stack, styleConnector); } break; } } if (num == 0) { break; } } } } } } break; case XamlNodeType.EndMember: { WpfXamlFrame currentFrame = stack.CurrentFrame; XamlMember property = currentFrame.Property; if ((!property.IsDirective || !(property == XamlReaderHelper.Freeze)) && property != WpfXamlLoader.XmlSpace.Value && property != XamlLanguage.Space) { xamlWriter.WriteNode(xamlReader); } currentFrame.Property = null; break; } case XamlNodeType.Value: WpfXamlLoader.WriteValue(xamlReader, xamlWriter, stack, styleConnector); break; case XamlNodeType.NamespaceDeclaration: xamlWriter.WriteNode(xamlReader); if (stack.Depth == 0 || stack.CurrentFrame.Type != null) { stack.PushScope(); for (WpfXamlFrame wpfXamlFrame = stack.CurrentFrame; wpfXamlFrame != null; wpfXamlFrame = (WpfXamlFrame)wpfXamlFrame.Previous) { if (wpfXamlFrame.XmlnsDictionary != null) { stack.CurrentFrame.XmlnsDictionary = new XmlnsDictionary(wpfXamlFrame.XmlnsDictionary); break; } } if (stack.CurrentFrame.XmlnsDictionary == null) { stack.CurrentFrame.XmlnsDictionary = new XmlnsDictionary(); } } stack.CurrentFrame.XmlnsDictionary.Add(xamlReader.Namespace.Prefix, xamlReader.Namespace.Namespace); break; default: xamlWriter.WriteNode(xamlReader); break; } if (onlyLoadOneNode) { return; } } }
private void ValidateTypeToMemberOnStack(XamlType type) { if (type.IsUnknown) { return; } if (type == this.xNull) { ValidateValueToMemberOnStack(null); } XamlMember member = _stack.TopFrame.Member; if (member == XamlLanguage.PositionalParameters || type.IsMarkupExtension || member.IsUnknown) { return; } if (member == XamlLanguage.Items) { XamlType collectionType = GetCollectionTypeOnStack(); if (collectionType == null || collectionType.IsUnknown || collectionType.AllowedContentTypes == null) { return; } if (!collectionType.AllowedContentTypes.Any(contentType => type.CanAssignTo(contentType))) { ValidationError(SR.UnassignableCollection(GetXamlTypeName(type), GetXamlTypeName(collectionType.ItemType), GetXamlTypeName(collectionType))); } } else if (member.IsDirective && (member.Type.IsCollection || member.Type.IsDictionary)) { XamlType collectionType = member.Type; if (collectionType == null || collectionType.IsUnknown || collectionType.AllowedContentTypes == null) { return; } if (!collectionType.AllowedContentTypes.Any(contentType => type.CanAssignTo(contentType))) { ValidationError(SR.UnassignableCollection(GetXamlTypeName(type), GetXamlTypeName(collectionType.ItemType), GetXamlTypeName(collectionType))); } } else if (!type.CanAssignTo(member.Type)) { if (member.DeferringLoader != null) { return; } if (NodeType == XamlNodeType.Value) { ValidationError(SR.UnassignableTypes(GetXamlTypeName(type), GetXamlTypeName(member.Type), member.Name)); } else { ValidationError(SR.UnassignableTypesObject(GetXamlTypeName(type), GetXamlTypeName(member.Type), member.Name)); } } }
private void ValidateMemberOnType(XamlMember member, XamlType type) { if (member.IsUnknown || type.IsUnknown) { return; } if (member.IsDirective) { if (member == XamlLanguage.Items) { if (!type.IsCollection && !type.IsDictionary) { ValidationError(SR.UnexpectedXamlDictionary(member.Name, GetXamlTypeName(_stack.TopFrame.Type))); } } if (member == XamlLanguage.Class && _stack.Depth > 1) { ValidationError(SR.UnexpectedXamlClass); } } else if (member.IsAttachable) { if (!type.CanAssignTo(member.TargetType)) { ValidationError(SR.UnexpectedXamlAttachableMember(member.Name, GetXamlTypeName(member.TargetType))); } } else if (!member.IsDirective && !type.CanAssignTo(member.DeclaringType)) { ValidationError(SR.UnexpectedXamlMemberNotAssignable(member.Name, GetXamlTypeName(type))); } }
internal XamlMember GetProperty(Int16 propertyId, XamlType parentType) { BamlProperty bamlProperty; XamlMember xamlMember; if (TryGetBamlProperty(propertyId, out bamlProperty, out xamlMember)) { if (xamlMember != null) { return xamlMember; } XamlType declaringType = GetXamlType(bamlProperty.DeclaringTypeId); // If the parent type & declaring type are assignable, then it could // be either a regular property or attachable. if (parentType.CanAssignTo(declaringType)) { xamlMember = declaringType.GetMember(bamlProperty.Name); if (xamlMember == null) { xamlMember = declaringType.GetAttachableMember(bamlProperty.Name); } } else { //If not assignable, it has to be an attachable member xamlMember = declaringType.GetAttachableMember(bamlProperty.Name); } lock (_syncObject) { _bamlProperty[propertyId] = xamlMember; } return xamlMember; } throw new KeyNotFoundException(); }
internal static void TransformNodes(System.Xaml.XamlReader xamlReader, System.Xaml.XamlObjectWriter xamlWriter, bool onlyLoadOneNode, bool skipJournaledProperties, bool shouldPassLineNumberInfo, IXamlLineInfo xamlLineInfo, IXamlLineInfoConsumer xamlLineInfoConsumer, XamlContextStack <WpfXamlFrame> stack, IStyleConnector styleConnector) { while (xamlReader.Read()) { if (shouldPassLineNumberInfo) { if (xamlLineInfo.LineNumber != 0) { xamlLineInfoConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition); } } switch (xamlReader.NodeType) { case System.Xaml.XamlNodeType.NamespaceDeclaration: xamlWriter.WriteNode(xamlReader); if (stack.Depth == 0 || stack.CurrentFrame.Type != null) { stack.PushScope(); // Need to create an XmlnsDictionary. // Look up stack to see if we have one earlier // If so, use that. Otherwise new a xmlnsDictionary WpfXamlFrame iteratorFrame = stack.CurrentFrame; while (iteratorFrame != null) { if (iteratorFrame.XmlnsDictionary != null) { stack.CurrentFrame.XmlnsDictionary = new XmlnsDictionary(iteratorFrame.XmlnsDictionary); break; } iteratorFrame = (WpfXamlFrame)iteratorFrame.Previous; } if (stack.CurrentFrame.XmlnsDictionary == null) { stack.CurrentFrame.XmlnsDictionary = new XmlnsDictionary(); } } stack.CurrentFrame.XmlnsDictionary.Add(xamlReader.Namespace.Prefix, xamlReader.Namespace.Namespace); break; case System.Xaml.XamlNodeType.StartObject: WriteStartObject(xamlReader, xamlWriter, stack); break; case System.Xaml.XamlNodeType.GetObject: xamlWriter.WriteNode(xamlReader); // If there wasn't a namespace node before this get object, need to pushScope. if (stack.CurrentFrame.Type != null) { stack.PushScope(); } stack.CurrentFrame.Type = stack.PreviousFrame.Property.Type; break; case System.Xaml.XamlNodeType.EndObject: xamlWriter.WriteNode(xamlReader); // Freeze if required if (stack.CurrentFrame.FreezeFreezable) { Freezable freezable = xamlWriter.Result as Freezable; if (freezable != null && freezable.CanFreeze) { freezable.Freeze(); } } DependencyObject dependencyObject = xamlWriter.Result as DependencyObject; if (dependencyObject != null && stack.CurrentFrame.XmlSpace.HasValue) { XmlAttributeProperties.SetXmlSpace(dependencyObject, stack.CurrentFrame.XmlSpace.Value ? "default" : "preserve"); } stack.PopScope(); break; case System.Xaml.XamlNodeType.StartMember: // ObjectWriter should NOT process PresentationOptions:Freeze directive since it is Unknown // The space directive node stream should not be written because it induces object instantiation, // and the Baml2006Reader can produce space directives prematurely. if (!(xamlReader.Member.IsDirective && xamlReader.Member == XamlReaderHelper.Freeze) && xamlReader.Member != XmlSpace.Value && xamlReader.Member != XamlLanguage.Space) { xamlWriter.WriteNode(xamlReader); } stack.CurrentFrame.Property = xamlReader.Member; if (skipJournaledProperties) { if (!stack.CurrentFrame.Property.IsDirective) { System.Windows.Baml2006.WpfXamlMember wpfMember = stack.CurrentFrame.Property as System.Windows.Baml2006.WpfXamlMember; if (wpfMember != null) { DependencyProperty prop = wpfMember.DependencyProperty; if (prop != null) { FrameworkPropertyMetadata metadata = prop.GetMetadata(stack.CurrentFrame.Type.UnderlyingType) as FrameworkPropertyMetadata; if (metadata != null && metadata.Journal == true) { // Ignore the BAML for this member, unless it declares a value that wasn't journaled - namely a binding or a dynamic resource int count = 1; while (xamlReader.Read()) { switch (xamlReader.NodeType) { case System.Xaml.XamlNodeType.StartMember: count++; break; case System.Xaml.XamlNodeType.StartObject: XamlType xamlType = xamlReader.Type; XamlType bindingBaseType = xamlType.SchemaContext.GetXamlType(typeof(BindingBase)); XamlType dynamicResourceType = xamlType.SchemaContext.GetXamlType(typeof(DynamicResourceExtension)); if (count == 1 && (xamlType.CanAssignTo(bindingBaseType) || xamlType.CanAssignTo(dynamicResourceType))) { count = 0; WriteStartObject(xamlReader, xamlWriter, stack); } break; case System.Xaml.XamlNodeType.EndMember: count--; if (count == 0) { xamlWriter.WriteNode(xamlReader); stack.CurrentFrame.Property = null; } break; case System.Xaml.XamlNodeType.Value: DynamicResourceExtension value = xamlReader.Value as DynamicResourceExtension; if (value != null) { WriteValue(xamlReader, xamlWriter, stack, styleConnector); } break; } if (count == 0) { break; } } System.Diagnostics.Debug.Assert(count == 0, "Mismatch StartMember/EndMember"); } } } } } break; case System.Xaml.XamlNodeType.EndMember: WpfXamlFrame currentFrame = stack.CurrentFrame; XamlMember currentProperty = currentFrame.Property; // ObjectWriter should not process PresentationOptions:Freeze directive nodes since it is unknown // The space directive node stream should not be written because it induces object instantiation, // and the Baml2006Reader can produce space directives prematurely. if (!(currentProperty.IsDirective && currentProperty == XamlReaderHelper.Freeze) && currentProperty != XmlSpace.Value && currentProperty != XamlLanguage.Space) { xamlWriter.WriteNode(xamlReader); } currentFrame.Property = null; break; case System.Xaml.XamlNodeType.Value: WriteValue(xamlReader, xamlWriter, stack, styleConnector); break; default: xamlWriter.WriteNode(xamlReader); break; } //Only do this loop for one node if loadAsync if (onlyLoadOneNode) { return; } } }
public virtual MethodInfo GetAddMethod(XamlType contentType) { if (contentType == null) { throw new ArgumentNullException("contentType"); } if (!this.IsUnknown && (this._xamlType.ItemType != null)) { MethodInfo addMethod; if ((contentType == this._xamlType.ItemType) || ((this._xamlType.AllowedContentTypes.Count == 1) && contentType.CanAssignTo(this._xamlType.ItemType))) { return this._xamlType.AddMethod; } if (!this._xamlType.IsCollection) { return null; } if (this._addMethods == null) { Dictionary<XamlType, MethodInfo> dictionary = new Dictionary<XamlType, MethodInfo>(); dictionary.Add(this._xamlType.ItemType, this._xamlType.AddMethod); foreach (XamlType type in this._xamlType.AllowedContentTypes) { addMethod = CollectionReflector.GetAddMethod(this._xamlType.UnderlyingType, type.UnderlyingType); if (addMethod != null) { dictionary.Add(type, addMethod); } } this._addMethods = dictionary; } if (this._addMethods.TryGetValue(contentType, out addMethod)) { return addMethod; } foreach (KeyValuePair<XamlType, MethodInfo> pair in this._addMethods) { if (contentType.CanAssignTo(pair.Key)) { return pair.Value; } } } return null; }
private IEnumerable <XamlNode> LogicStream_CheckForStartGetCollectionFromMember() { XamlType type1 = this._context.CurrentType; XamlMember currentMember = this._context.CurrentMember; XamlType type = currentMember.Type; XamlType iteratorVariable2 = (this._xamlScanner.NodeType == ScannerNodeType.TEXT) ? XamlLanguage.String : this._xamlScanner.Type; if (type.IsArray && (this._xamlScanner.Type != this.ArrayExtensionType)) { IEnumerable <NamespaceDeclaration> newNamespaces = null; XamlTypeName iteratorVariable4 = new XamlTypeName(type.ItemType); INamespacePrefixLookup prefixLookup = new NamespacePrefixLookup(out newNamespaces, new Func <string, string>(this._context.FindNamespaceByPrefix)); string data = iteratorVariable4.ToString(prefixLookup); foreach (NamespaceDeclaration iteratorVariable7 in newNamespaces) { yield return(new XamlNode(XamlNodeType.NamespaceDeclaration, iteratorVariable7)); } yield return(this.Logic_StartObject(this.ArrayExtensionType, null)); this._context.CurrentInImplicitArray = true; yield return(this.Logic_StartMember(this.ArrayTypeMember)); yield return(new XamlNode(XamlNodeType.Value, data)); yield return(this.Logic_EndMember()); yield return(this.Logic_EndOfAttributes()); yield return(this.Logic_StartMember(this.ItemsTypeMember)); XamlType currentType = this._context.CurrentType; currentMember = this._context.CurrentMember; type = currentMember.Type; } if (!currentMember.IsDirective && (type.IsCollection || type.IsDictionary)) { bool iteratorVariable8 = false; if (currentMember.IsReadOnly || !this._context.CurrentMemberIsWriteVisible()) { iteratorVariable8 = true; } else if (((type.TypeConverter != null) && !currentMember.IsReadOnly) && (this._xamlScanner.NodeType == ScannerNodeType.TEXT)) { iteratorVariable8 = false; } else if (((iteratorVariable2 == null) || !iteratorVariable2.CanAssignTo(type)) && (iteratorVariable2 != null)) { if (!iteratorVariable2.IsMarkupExtension || this._xamlScanner.HasKeyAttribute) { iteratorVariable8 = true; } else if (iteratorVariable2 == XamlLanguage.Array) { iteratorVariable8 = true; } } if (iteratorVariable8) { yield return(this.Logic_StartGetObjectFromMember(type)); yield return(this.Logic_StartItemsProperty(type)); } } }
/// <summary> /// Resolves a property of the form 'Foo.Bar' or 'a:Foo.Bar', in /// in the context of a parent tag. The parent tagType may or may not /// be covariant with the ownerType. In the case of dotted attribute /// syntax, the namespace my be passed in. /// </summary> /// <param name="tagType">The xamlType of the enclosing Tag</param> /// <param name="tagNamespace">The namespace of the enclosing Tag</param> /// <param name="propName">The dotted name of the property</param> /// <param name="tagIsRoot">Whether the tag is the root of the document</param> /// <returns></returns> public XamlMember GetDottedProperty(XamlType tagType, string tagNamespace, XamlPropertyName propName, bool tagIsRoot) { if (tagType == null) { throw new XamlInternalException(SR.Get(SRID.ParentlessPropertyElement, propName.ScopedName)); } XamlMember property = null; XamlType ownerType = null; string ns = ResolveXamlNameNS(propName); if (ns == null) { throw new XamlParseException(SR.Get(SRID.PrefixNotFound, propName.Prefix)); } XamlType rootTagType = tagIsRoot ? tagType : null; // If we have <foo x:TA="" foo.bar=""/> we want foo in foo.bar to match the tag // type since there is no way to specify generic syntax in dotted property notation // If that fails, then we fall back to the non-generic case below. bool ownerTypeMatchesGenericTagType = false; if (tagType.IsGeneric) { ownerTypeMatchesGenericTagType = PropertyTypeMatchesGenericTagType(tagType, tagNamespace, ns, propName.OwnerName); if (ownerTypeMatchesGenericTagType) { property = GetInstanceOrAttachableProperty(tagType, propName.Name, rootTagType); if (property != null) { return(property); } } } // Non-generic case, just resolve using the namespace and name XamlTypeName ownerTypeName = new XamlTypeName(ns, propName.Owner.Name); ownerType = GetXamlType(ownerTypeName, true); bool canAssignTagTypeToOwnerType = tagType.CanAssignTo(ownerType); if (canAssignTagTypeToOwnerType) { property = GetInstanceOrAttachableProperty(ownerType, propName.Name, rootTagType); } else { property = GetXamlAttachableProperty(ownerType, propName.Name); } if (property == null) { // This is an unknown property. // We don't know for sure whether or not it's attachable, so we go with our best guess. // If the owner type is same as the generic tag type, or is assignable to the tag type, // it's probably not attachable. XamlType declaringType = ownerTypeMatchesGenericTagType ? tagType : ownerType; if (ownerTypeMatchesGenericTagType || canAssignTagTypeToOwnerType) { property = CreateUnknownMember(declaringType, propName.Name); } else { property = CreateUnknownAttachableMember(declaringType, propName.Name); } } return(property); }
private void InjectPropertyAndFrameIfNeeded(XamlType elementType, SByte flags) { // If we saved the Node stream for the first ME element of a dictionary to // check if it had a key then process that now. if (_lookingForAKeyOnAMarkupExtensionInADictionaryDepth == _context.CurrentFrame.Depth) { RestoreSavedFirstItemInDictionary(); } XamlType parentType = _context.CurrentFrame.XamlType; XamlMember parentProperty = _context.CurrentFrame.Member; if (parentType != null) { if (parentProperty == null) { // We have got two consecutive ElementStart records // We must insert an implicit content property between them if (_context.CurrentFrame.ContentProperty != null) { _context.CurrentFrame.Member = parentProperty = _context.CurrentFrame.ContentProperty; } else if (parentType.ContentProperty != null) { _context.CurrentFrame.Member = parentProperty = parentType.ContentProperty; } else { if (parentType.IsCollection || parentType.IsDictionary) { _context.CurrentFrame.Member = parentProperty = XamlLanguage.Items; } else if (parentType.TypeConverter != null) { _context.CurrentFrame.Member = parentProperty = XamlLanguage.Initialization; } else { throw new XamlParseException(SR.Get(SRID.RecordOutOfOrder, parentType.Name)); } } _context.CurrentFrame.Flags = Baml2006ReaderFrameFlags.HasImplicitProperty; _xamlNodesWriter.WriteStartMember(parentProperty); // if we are NOT already spooling a template if (_context.TemplateStartDepth < 0 && _isBinaryProvider) { if (parentProperty == BamlSchemaContext.FrameworkTemplateTemplateProperty) { // If this is a template then spool the template into a Node List. _context.TemplateStartDepth = _context.CurrentFrame.Depth; _xamlTemplateNodeList = new XamlNodeList(_xamlNodesWriter.SchemaContext); _xamlWriterStack.Push(_xamlNodesWriter); _xamlNodesWriter = _xamlTemplateNodeList.Writer; } } } XamlType parentPropertyType = parentProperty.Type; // Normally an error except for collections if (parentPropertyType != null && (parentPropertyType.IsCollection || parentPropertyType.IsDictionary) && !parentProperty.IsDirective && (flags & ReaderFlags_AddedToTree) == 0) { bool emitPreamble = false; // If the collection property is Readonly then "retrieve" the collection. if (parentProperty.IsReadOnly) { emitPreamble = true; } // OR if the Value isn't assignable to the Collection emit the preable. else if (!elementType.CanAssignTo(parentPropertyType)) { // UNLESS: the Value is a Markup extension, then it is assumed that // the ProvidValue type will be AssignableFrom. if (!elementType.IsMarkupExtension) { emitPreamble = true; } // EXCEPT: if the BAML said it was Retrived else if (_context.CurrentFrame.Flags == Baml2006ReaderFrameFlags.HasImplicitProperty) { emitPreamble = true; } // OR: the ME is Array else if (elementType == XamlLanguage.Array) { emitPreamble = true; } } if (emitPreamble) { EmitGoItemsPreamble(parentPropertyType); } // We may need to look for an x:Key on the ME in a dictionary. // so save up the node stream for the whole element definition and check it // for an x:Key later. if (!emitPreamble && parentPropertyType.IsDictionary && elementType.IsMarkupExtension) { StartSavingFirstItemInDictionary(); } } } }
private IEnumerable <XamlNode> LogicStream_CheckForStartGetCollectionFromMember() { XamlType currentType = _context.CurrentType; XamlMember currentProperty = _context.CurrentMember; XamlType propertyType = currentProperty.Type; XamlType valueElementType = (_xamlScanner.NodeType == ScannerNodeType.TEXT) ? XamlLanguage.String : _xamlScanner.Type; if (propertyType.IsArray && _xamlScanner.Type != ArrayExtensionType) { IEnumerable <NamespaceDeclaration> newNamespaces = null; XamlTypeName typeName = new XamlTypeName(propertyType.ItemType); INamespacePrefixLookup prefixResolver = new NamespacePrefixLookup(out newNamespaces, _context.FindNamespaceByPrefix); string typeNameString = typeName.ToString(prefixResolver); // SideEffects!!! prefixResolver will populate newNamespaces foreach (NamespaceDeclaration nsDecl in newNamespaces) { yield return(new XamlNode(XamlNodeType.NamespaceDeclaration, nsDecl)); } yield return(Logic_StartObject(ArrayExtensionType, null)); _context.CurrentInImplicitArray = true; yield return(Logic_StartMember(ArrayTypeMember)); yield return(new XamlNode(XamlNodeType.Value, typeNameString)); yield return(Logic_EndMember()); yield return(Logic_EndOfAttributes()); yield return(Logic_StartMember(ItemsTypeMember)); currentType = _context.CurrentType; currentProperty = _context.CurrentMember; propertyType = currentProperty.Type; } // Now Consider inserting special preamble to "Get" the collection: // . GO // . . SM _items if (!currentProperty.IsDirective && (propertyType.IsCollection || propertyType.IsDictionary)) { bool emitPreamble = false; // If the collection property is Readonly then "Get" the collection. if (currentProperty.IsReadOnly || !_context.CurrentMemberIsWriteVisible()) { emitPreamble = true; } // If the collection is R/W and there is a type converter and we have Text // use the type converter rather than the GO; SM _items; else if (propertyType.TypeConverter != null && !currentProperty.IsReadOnly && _xamlScanner.NodeType == ScannerNodeType.TEXT) { emitPreamble = false; } // Or if the Value (this is the first value in the collection) // isn't assignable to the Collection then "Get" the collection. else if (valueElementType == null || !valueElementType.CanAssignTo(propertyType)) { if (valueElementType != null) { // Unless: the Value is a Markup extension, in which case it is // assumed that the ProvideValue() type will be AssignableFrom // or If the next object has an x:Key in which case it must be // a dictionary entry. // so Don't "Get" the collection. if (!valueElementType.IsMarkupExtension || _xamlScanner.HasKeyAttribute) { emitPreamble = true; } // Except: the Array Extension can never return a dictionary // so for Array Extension do "Get" the collection. // Note Array Extension would be suitable for List Collections // Note: a fully validating parser should look at MarkupExtensionReturnType // for this choice, there might be other MarkupExtensions that fit this. else if (valueElementType == XamlLanguage.Array) { emitPreamble = true; } } } if (emitPreamble) { yield return(Logic_StartGetObjectFromMember(propertyType)); yield return(Logic_StartItemsProperty(propertyType)); } } }